On Fri, Sep 01, 2000 at 10:46:50AM +0100, Piers Cawley wrote:
> Are you wilfully misunderstanding me?
I would appreciate you giving me the benefit of the doubt that I'm not
intentially misunderstanding you.
> Let's try another possible example to see if you get the point:
>
> print "What sort of dog do you want? ";
> my $dog_type = ucfirst(<STDIN>); chomp $dog_type;
>
> try {
> my Dog $puppy = "Dog::${dog_type}"->new(name => $dog_name);
> }
> catch Exception::BadType {
> croak "Dog::${dog_type} is not a valid breed\";
> }
> catch {
> croak $!;
> }
>
> I want 'my Dog $spot' to enforce the condition that:
>
> (!defined($spot) || $spot->isa('Dog'))
Yes, I had gathered this. I tried to tell you that's not what I'm
proposing.
> And that is all. I *really* don't the idea of implicit object
> creation. Consider other OO languages; C++ has implicit object
> construction, but has added the explicit and implicit keywords to
> enable the programmer to turn the behaviour off. Not having actually
> programmed in C++ I don't know how often you want to do this, but the
> fact that the functionality is informative. In Java, on the other
> hand, the designers looked at C++ and decided *not* to do implicit
> construction.
This is not how I understand C++. Granted, I've only done a few programs in
it, but there is no implicit keyword (at least, not mentioned in the /C++
Primer/ second edition), and the explicit keyword has to do with implicit
type conversions.
In C++ the code:
string foo;
makes foo a string object right then and there, calling the constructor
string::string(). explicit will not affect this. Taking an example from my
book, given the class definition:
class Number {
public:
explicit Number(const SmallInt &);
};
The code:
void func(Number);
SmallInt si(47);
func(si);
will cause an error at compile-time, because si cannot be successfully
converted to a Number; the explicit keyword prevents the appropriate
constructor from participating in an implicit conversion.
my string $foo is the C++ equivalent of string foo; it instantiates a
string object in $foo.
> But $spot could easily be a Dalmation object that you are using like a
> Dog in the current context. Maybe I should just write a counter
> proposal along the lines of:
>
> =head1 TITLE
>
> C<my Dog $spot> should simply assert that
> C<(!defined($spot) || $spot-E<gt>isa('Dog'))>
>
> And let them duke it out.
By all means, please do so.
Declaring $spot is a Dog (without turning it into a Dog object) and the
changes I propose are not mutually exclusive unless you want to use the same
syntax. We could use something like:
my $spot isa(Foo);
But, whatever.
Michael
--
Administrator www.shoebox.net
Programmer, System Administrator www.gallanttech.com
--
