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▀)



Reply via email to