Perl 6 vs Python 3

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

class junction {
    has &.predicate;
    has @.items;

    method new(&predicate, *@items) {
        self.bless(:&predicate, :@items);
    }
}

multi sub infix:<+>(junction $j, $o) { $j.items .= map(* + $o); $j }
multi sub infix:<+>($o, junction $j) { $j + $o }

multi sub infix:<*>(junction $j, $o) { $j.items .= map(* * $o); $j }
multi sub infix:<*>($o, junction $j) { $j * $o }

multi sub infix:<->(junction $j, $o) { $j.items .= map(* - $o); $j }
multi sub infix:<->($o, junction $j) { $j.items .= map($o - *); $j }

multi sub infix:</>(junction $j, $o) { $j.items .= map(* / $o); $j }
multi sub infix:</>($o, junction $j) { $j.items .= map($o / *); $j }

multi sub infix:«>»(junction $j, $o) { so $j.predicate()(|$j.items.map(* > $o)) }
multi sub infix:«>»($o, junction $j) { so $j.predicate()(|$j.items.map($o > *)) }

multi sub infix:«<»(junction $j, $o) { not $j > $o }
multi sub infix:«<»($o, junction $j) { not $j < $o }

multi sub infix:<==>(junction $j, $o) { so $j.predicate()(|$j.items.map(* eq $o)) }
multi sub infix:<==>($j, junction $o) { $o == $j }

multi sub infix:<!=>(junction $j, $o) { not $j == $o }
multi sub infix:<!=>($j, junction $o) { not $o == $j }

my $j1 = junction.new(&any, 1, 2, 3);
say 3 == $j1 + 1;

my $j2 = junction.new(&all, 1, 2, 3);
say 10 > $j2 * 5 - 7;

my $j3 = junction.new(&one, 4, 6, 8);
say 0 < $j3 / 2 - 3;

my $j4 = junction.new(&none, "hello", "world", "");
say "hello" != $j4;


sub any(*@a) { so [||] @a }

sub all(*@a) { so [&&] @a }

sub one(*@a) { so [^^] @a }

sub none(*@a) { not any @a }

so $j.predicate()(|$j.items.map(* > $o)) расписывается, конечно, в что-то такое:

my &pred = $j.predicate;
my @items = $j.items.map(* > $o);
&pred(|@items).Bool;

чтобы понятнее было.

$j.items .= map(* + $o); $j расписывается в

$j.items = $j.items.map(-> $el { $el + $o });
return $j;

Портировал, но пришлось без декоратора, потому что я сейчас слабо представляю, как и, главное, зачем.

Если ты про wrapper с generic_method, то это ж элементарщина:
1. Нам надо, чтобы к экземплярам класса junction можно было применять всякие операторы. В питоне эта машинерия устроена как дерганье соответствующих «специальных» методов (вида __%metodname%__). Значит, надо прописать классу эти методы.
2. Я выбрал самый дубовый. В самом теле класса циклом устанавливаю ему «всеядный» псевдометод — функцию, которая принимает любое количество любых аргументов и, соответственно, может успешно имитировать интерфейс и арность любого метода.
_wrapattr остался от предыдущей версии, я об этом писал в пред. комментарии, но пихать его в generic_method показалось совсем плохой идеей: как-то всё перегружено будет выглядеть. Так и оставил.
3. Итого, класс успешно складывается, делится, множится и вычитается, остальное дело техники.

Итого, класс успешно ... множится

На ноль?

Если ты про wrapper с generic_method, то это ж элементарщина:

Извиняюсь, я имел в виду «как и зачем в Perl 6», в питоне понятно, что ты декорируешь каждый магический метод с обёрткой, которая обходит список элементов, дёргая его.

Писать декораторы здесь тоже можно, можно даже сахар сделать, причём используя обычный механизм кастомных трейтов, а не что-то специальное для этого случая. Можно ли/как обойти реализацию операторов я не в курсе, может как-то и можно, но решил писать как пишется.