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