develooper Front page | perl.perl6.language | Postings from April 2005

Re: Sun Fortress and Perl 6

Thread Previous | Thread Next
From:
=?ISO-8859-1?Q?Thomas_Sandla=DF?=
Date:
April 29, 2005 02:07
Subject:
Re: Sun Fortress and Perl 6
Message ID:
4271F954.9020808@orthogon.com
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Ɵ)


Thread Previous | Thread Next


nntp.perl.org: Perl Programming lists via nntp and http.
Comments to Ask Bjørn Hansen at ask@perl.org | Group listing | About