John M. Dlugosz wrote:
 sub GetType (-->Type) { ... }
 my ::RunTimeType := GetType;

I think my declares value variables which means you need
a sigil:

   my ::RunTimeType $ := GetType;

and of course you capture the runtime type of the
return value of GetType. If you write that as

   my ::RunTimeType $ := &GetType;

you get the type of &GetType itself that is :(-->Type).

Also, is this the normal way of making typedefs?

   my ::Newname := OldTypeName;

I guess not. But

   ::Newname ::= OldTypeName;

should work. The type system is a runtime overlay to
the value system. This is reflected in the source by
putting types and values into different syntactic slots.
You cannot mix these!

I unify class and code conceptually and Perl 6 might
unify them actually. That is I think invoking a sub
essentially means:

   sub foo ($x) {...}

   $x = &foo.new(3);

   class foo ($x) {...}  # constructor syntax?

   $y = ::foo.new(3);    # perhaps also: ::foo(3)

   $z = foo 3; # ambiguous or &foo?

If you wanted more than one constructor you'd need to prefix
it with multi.

BTW, I wonder why S12 is wasting {} for parent class construction:

    class Dog is Animal {...}
    my $pet = Dog.new( :name<Fido>, Animal{ :blood<warm>, :legs(4) } );

Wouldn't parens be sufficient? Looks like Type{} now means protoobject
construction and Type() means concrete object construction. And Type[]
means type construction. So what exactly can one do with a protoobject?
And what is a protoinvocation of a sub? When is it evaluated?
Finally I wonder why we didn't give a meaning to Type<>? Does that
look too much like C++, C# or Java templates?

Regards, TSa.

"The unavoidable price of reliability is simplicity"
  -- C.A.R. Hoare

Reply via email to