что это делает, это принять значение, которое является подтипом прохладный, и пытается преобразовать его в Int. В этот момент is an Int независимо от того, что это было раньше.

так

sub double ( Int(Cool) $n ) { $n * 2 }

действительно можно подумать о том, как (я думаю, что это было фактически реализовано в Ракудо )

# Int is a subtype of Cool otherwise it would be Any or Mu
proto sub double ( Cool $n ) {*}

# this has the interior parts that you write
multi sub double (  Int $n ) { $n * 2 }

# this is what the compiler writes for you
multi sub double ( Cool $n ) {
    # calls the other multi since it is now an Int
    samewith Int($n);
}

так это принимает любой из Int, Str, крыса, FatRat, Num, массив, хэш, etc. и пытается преобразовать его в Int перед вызовом &infix:<*>, и 2.

say double '  5  '; # 25
say double 2.5;     # 4
say double [0,0,0]; # 6
say double { a => 0, b => 0 }; # 4

вы можете ограничить его в прохладный вместо любой, как все прохладный значения по существу необходимы для обеспечения принуждения к Int.

( :( Int(Any) $ ) можно сократить до просто :( Int() $ ) )

причина, по которой вы можете это сделать, заключается в том, что вам нужно, чтобы это было Int внутрь, потому что вы вызываете другой код, который делает разные вещи с разными типами.

sub example ( Int(Cool) $n ) returns Int {
    other-multi( $n ) * $n;
}

multi sub other-multi ( Int $ ) { 10 }
multi sub other-multi ( Any $ ) {  1 }

say example 5;   # 50
say example 4.5; # 40

в этом конкретном случае вы могли бы написать его как один из этих

sub example ( Cool $n ) returns Int {
    other-multi( Int($n) ) * Int($n);
}

sub example ( Cool $n ) returns Int {
    my $temp = Int($n);
    other-multi( $temp ) * $temp;
}

sub example ( Cool $n is copy ) returns Int {
    $n = Int($n);
    other-multi( $n ) * $n;
}

ни один из них не так ясно, как тот, который использует подпись, чтобы принудить его для вас.

как правило, для такой простой функции вы можете использовать один из них и он, вероятно, сделает то, что вы хотите.

my &double = * * 2; # WhateverCode
my &double = * × 2; # ditto

my &double = { $_ * 2 };       # bare block
my &double = { $^n * 2 };      # block with positional placeholder
my &double = -> $n { $n * 2 }; # pointy block

my &double = sub ( $n ) { $n * 2 } # anon sub
my &double = anon sub double ( $n ) { $n * 2 } # anon sub with name

my &double = &infix:<*>.assuming(*,2); # curried
my &double = &infix:<*>.assuming(2);

sub double ( $n ) { $n * 2 } # same as :( Any $n )

Я что-то пропустила? Я не эксперт Perl 6, но, похоже, синтаксис позволяет независимо указывать оба какие типы входных данных допустимы и как входные данные будут представлены функции.

ограничение допустимого ввода полезно, потому что это означает, что код приведет к ошибке, а не к бесшумному (бесполезному) преобразованию типа, когда функция вызывается с бессмысленным параметром.

Я не думаю, что пример, когда два типа не находятся в иерархических отношениях, имеет смысл.

Я считаю, что ответ так же прост, как вы не хотите ограничивать аргумент Int даже если вы будете относиться к нему как Int в рамках подгруппы. скажем, по какой-то причине вы хотите умножить массив на хэш, но потерпите неудачу, если args нельзя рассматривать как Int (т. е. не Cool).

my @a = 1,2,3;
my %h = 'a' => 1, 'b' => 2;
say @a.Int; # 3 (List types coerced to the equivalent of .elems when treated as Int)
say %h.Int; # 2

sub m1(Int $x, Int $y) {return $x * $y}
say m1(3,2); # 6
say m1(@a,%h); # does not match

sub m2(Int(Cool) $x, Int(Cool) $y) {return $x * $y}
say m2('3',2); # 6
say m2(@a,%h); # 6
say m2('foo',2); # does not match

конечно, вы также можете сделать это без подписи, потому что математическая операция автоматически принудит тип:

sub m3($x,$y) {return $x * $y}
say m3(@a,%h); # 6

все подтипы Cool будет (как круто требует от них) принужден к Int. Поэтому, если оператор или подпрограмма, внутренняя для вашего суб, работает только с Int аргументы, вам не нужно добавлять дополнительный оператор / выражение, преобразующее в Int, и код этого оператора / подпрограммы не должен учитывать другие подтипы Cool. Это приводит к тому, что аргумент будет Int внутри подгрупп, где вы используете его.

ваш пример наоборот:

class Foo { method foomethod { say 'foomethod' } }
class Bar {}

class Quux is Bar {
  method Foo { Foo.new }
}

sub foo(Foo(Bar) $c) {
#= converts $c of type Bar to type Foo
#= returns result of foomethod
  say $c.WHAT;    #-> (Foo)
  $c.foomethod    #-> foomethod
}

foo(Quux.new)