# Re: clarifying the spec for 'ref'

```On 8/25/06, Daniel Hulme <[EMAIL PROTECTED]> wrote:
```
```That's because you're used to one way of thinking about class
inheritance: that the subclass can do everything that the superclass can
do, and more. In this scheme, you might have a Square class, with a
field representing its corner and another giving its side length. Then,
you could build on this to have Rectangle as a subclass, which adds an
extra side length, and extra accessors for it. This is a really bad way
of making your subclasses work, but your Rectangle has all the fields
and methods of your Square, and some extra ones.
```
```
This is the well-known Circle/Ellipse problem, and it relates to the
theory of value types.

We'll first take the traditional conception that a Square is a
Rectangle, the opposite of your viewpoint.  This is based on the
geometrical definitions of these shapes.  This makes sense from a
usage standpoint:

sub rect_perimiter(Rectangle \$x) {
2*\$x.width + 2*\$x.height;
}
sub square_perimiter(Square \$x) {
4*\$x.width;
}

It makes sense to pass a Square to rect_perimiter, but not to pass a
Rectangle to square_perimiter.  That is one indication that Square is
a subtype of Rectangle.

However, say that Rectangle had set_height() and set_width() methods.
You cannot set the height and width of a square independently, so a
function like this:

sub make_dims(Rectangle \$r, \$w, \$h) {
\$r.set_width(\$w);
\$r.set_height(\$h);
POST { \$r.area == \$w * \$h }
}

Must fail if \$w and \$h are not equal (and depending on Square's
implementation, might fail if they are equal).  You could say that the
failure is on the implementation side: we couldn't implement set_width
and set_height appropriately.

So clearly a Square is not a Rectangle.

Let's look at the other way around (your viewpoint):  a Rectangle is a
Square.  This makes sense from an implementation point of view, as you
point out.  We just take Square's methods and add a couple of
capabilites.

However:

sub area(Square \$x) {
\$x.width ** 2;
}

Fails (by returning the wrong thing, worse than dying) if you pass it
a Rectangle.  So it failed from the usage point of view.  You could
say "that should be a method", but then you should say that everything
that uses a square should be a method of square, because we must be
able to make assumptions about the  behavior of classes.  If you say
that my sub makes an assumption that it shouldn't, realize that the
only thing it is assuming is that a Square is a geometrical square.
If I can't make that assumption, then Square is not a very good name
for that class.

So clearly a Rectangle is not a Square.

One way failed on the implementation side, the other on the usage
side.  I'd argue that the "Rectangle is a Square" view's validity can
only be argued from an implementation laziness point of view (which is
okay, but it must also be balanced with other issues).

The "Square is a Rectangle" point of view only works if they are value
types: if you are not allowed to modify anything.  In that
circumstance, it works very cleanly[1].  But if you are allowed to
modify things, then the two classes must be siblings, not parent-child
related.

Luke
```