Goals

The test objects are Point2d and Point3d. No interface inheritance is needed, but it can help.

Goal #1

Point2d and Point3d must have methods:

• translate which translates the point on the X-axis
  translate :: Point a => a -> Double -> a
• length which computes the distance to the origin
  length :: Point a => a -> Double

and you must have external access to Point3d'z:

• z or get_z :: Point3d -> Double

Goal #2

Same as goal #1, but adding the (binary) method:

• add which adds the point coordinates
  add :: Point a => a -> a -> a

Adding a Point2d and a Point3d should cause a compile-time error or runtime-error. This imply an absence of subtyping relationship between Point2d ad Point3d.

Goal #3

Same as goal #2, but having subtyping (or simulating it) between Point2d and Point3d for "add" method. This means the following combinaisons should be allowed:

• add :: Point2d -> Point2d -> Point2d
• add :: Point2d -> Point3d -> Point2d
• add :: Point3d -> Point2d -> Point2d
• add :: Point3d -> Point3d -> Point3d

Note: p1.add(p2) returning a Point2d even if both p1 and p2 are Point3d's doesn't fulfill goal #3.

Implementations

Goal #1

Common Lisp
Dylan
Python
Ruby
Java	need some downcasting back from Point to Point2d or Point3d
C++	no runtime error
Haskell	no runtime error (uses existential types)
OCaml	no runtime error
merd	no runtime error
nice	no runtime error

Goal #2

Common Lisp
Dylan
Python	explicit "add" argument runtime type checking
Ruby	explicit "add" argument runtime type checking
Java	explicit "add" argument runtime type checking need some downcasting back from Point to Point2d or Point3d
C++	explicit "add" argument runtime type checking
Haskell	no runtime error but can't make a list of points having the ability to use "add"
Haskell	explicit "add" argument runtime type checking uses unpacking from existential type back to real type
OCaml	no runtime error but can't make a list of points having the ability to use "add"
merd	no runtime error
nice	no runtime error

Goal #3

Common Lisp
Dylan
Python	explicit runtime dispatching
Ruby	explicit runtime dispatching
Java	no runtime error explicit runtime dispatching need some downcasting back from Point to Point2d or Point3d
C++	no runtime error explicit runtime dispatching
Haskell	no runtime error explicit runtime dispatching uses unpacking from existential type back to real type
Haskell	no OO, using a variant for unifying Point2d and Point3d
OCaml	no OO, using a variant for unifying Point2d and Point3d
merd	no runtime error
nice	no runtime error

Remarks

• Versions using less compile-time checks are usually the easiest to write:

  • non-OO Haskell and OCaml versions are the simplest, but do not allow precise enough typing: no distinction between Point2d and Point3d is done at compile time. So the only way to have a function working only on Point3d's is to raise an error when that function is called with a Point2d (see get_z)

  • Ruby and Python versions are quite simple, not bothering too much with types. The only trick is the hand-written late-dispatching for Point3d.add(Point2d) (Goal #3), and disallowing Point3d.add(Point2d) and Point2d.add(Point3d) (Goal #2)

  • Common Lisp & Dylan are alike Ruby/Python without the burden of handling add(Point3d, Point2d) and add(Point2d, Point3d). The difference between Goal #2 or Goal #3 comes from having Point3d a subtype of Point2d or not. multi-methods are nice :)

  • Java (< Java2 5.0) do not benefit much from its type system. The lack of generics do not allow much. For translate a solution is to define it with the precise return type in both Point2d and Point3d. twice returning a Point3d when given a Point3d is only possible with twice defined as a method in both Point2d and Point3d. Also note that const does not exist in Java.

• C++ Goal #1 is quite good (though quite hard to write) and achieve perfect type safeness. C++ Goal #3 is a bit more complicated but also achieve perfect type safeness. To achieve this, template functions are used. Note that memory freeing is not done and would kill usability!

• OCaml Goal #2 is a quite good Goal #2

• merd versions are simply perfect (warning: the author may be biased on this one, make your own opinion)

Release: $Id$