Re: Sun Fortress and Perl 6

Autrijus Tang wrote:
> 1. Type variables as role parameters
> [..]
> Curiously, A12 and S12 already allows something like that:
>
>     role List[Type $t] {
>         method first() returns ::($t);
>         method rest() returns List[::($t)];
>         method cons(::($t) $x) returns List[::($t)];
>         method append(List[::($t)] $xs) returns List[::($t)];
>     }
>
> But I am not at all sure if this is the correct notation --
> specifically, the "Type" type is not explained, and I'm not sure
> how they are instantiated during the type checking phase at the
> compile time.  Furthermore, I'm not sure that the ::($t) notation
> is correct above.

Well, the ::() is the symbolic name syntax while ::Type is a
sigiled type/class/role etc. without prior declaration. This
is at least the way Damian used it. So the above could be

role List[ ::Type ]  # immediately introduces Type
{
    method first() returns Type;
    method rest() returns List[Type];
    method cons(Type $x) returns List[Type];
    method append(List[Type] $xs) returns List[Type];
}

Actually the same applies for all types:

my ::Foo $foo;

Even I don't know exactly when ::Foo has to be available at the latest.


> -----------------------------------------------------------------
>
> 2. Tuple types
>
>     sub foo () returns (Int, Bool, Array) {

I think we have that. It's

sub foo () returns :(Int, Bool, Array) {...}

If you like you could use :() for the sig as well.
And it might be applicable for variables, too.

my @a:( Int, Bool, Array) = (23, true, [1,2,3] );

my %h:( count => Int, state => Bool, data => Array )
    = { count =>  23, state => true, data => [1,2,3] };

%h<foo> = "blubb";  # type error "no such field"
%h<state> = 8;      # type error "%h<state>:(Bool)"

A function type could be &:(Str,Int,Int):(Str) or so.
Actually &(Str,Int,Int):(Str) looks better.
But we have &foo:(Str,Int,Int) OTOH. So I'm unsure here.
Even sub foo():(Int) {...} might be OK.

In general I think we have:

  ( term )
 :( type spec )
::( symbolic ref/name )


> -----------------------------------------------------------------
>
> 3. Labels applies to blocks, not statements

Accordding to Luke that hasn't really been on the agenda.
But the postfix colon is heavily wanted elsewhere. With
Block as a Code subclass we might have:

block foo
{
   say "Hello!";
   say "Hi!";
}


Regards,
--
TSa (Thomas Sandlaß)