16. Создание своих операторов в Perl 6, часть 3

В третьей части мы рассмотрим еще два вида операторов — circumfix и postcircumfix. Начнем с более сложного на вид названия.

Postcircumfix

С операторами такого типа вы все встречались: типичный пример — индексирование массива: @a[$i]. Сам по себе оператор — это пара скобок. Операнды (аргументы) оператора — массив и индекс.

Еще два примера — круглые скобки для вызова функции и угловые скобки для создания массива:

my @a = < a b c >;

Создадим свой:

sub postcircumfix:<¿ ?>(Str $question, Str $answer) {
    say "Q: $question";
    say "A: $answer";
}

"Hello"¿"World"?;

Эта программа напечатает следующее:

Q: Hello
A: World

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

Circumfix

Этот тип оператора еще менее похож на оператор, но тем не менее, с точки зрения языка, это полноправный оператор. Рассмотрим пример с теми же символами:

sub circumfix:<¿ ?>(Str $str) {
    $str.chars
}

say ¿'Hello, World!'?; # 13

Программа печатает длину строки. Вопросительные знаки стали двумя частями оператора, одна часть стоит до, вторая после операнда.

15. Создание своих операторов в Perl 6, часть 2

Пару дней назад мы создавали префиксный оператор и обещали посмотреть на другие виды, существующие в Perl 6. Давайте сделаем это сегодня.

Постфиксы

С префиксами все просто: это оператор, стоящий перед своим единственным операндом. Ровно то же, но наоборот, с постфиксом. Однако стоит понимать, что префиксный и постфиксный операторы, даже если они имеют одинаковый вид, полностью независимы. Можно даже сделать так, что они будут работать противоположно.

Типичный пример постфиксного оператора — инкремент ++ или декремент --. Классика кастомного постфиксного оператора — факториал:

sub postfix:<!>(Int $n) {
    [*] 1..$n
}

say 5!; # 120

Инфиксы

Следующий тип — инфиксы. Таких операторов большинство; эти операторы стоят между двумя операндами, например, $a + $b или $a ... $b. Уверен, вы без труда сможете создать собственный оператор при необходимости. Например:

sub infix:<≈>($a, $b) {
    abs($a) - abs($b) < 1
}

say 3.14 ≈ pi; # True

(В Perl 6 уже есть встроенный оператор приблизительного равенства: =~= или , который устроен чуть более сложно.)

14. Программа с эмотиконами для самостоятельного разбора

Сегодня вашему вниманию предлагается программа на Perl 6 для самостоятельного изучения.

class 人 {
    has $.name;
    has $.sex;
    has $.phone is rw;
    
    method gist {
        "$.sex $.name"
    }
}

sub prefix:<👨>($name) {
    人.new(name => $name, sex => '👨')
}

sub prefix:<👩>($name) {
    人.new(name => $name, sex => '👩')
}

sub infix:<☎️>(人 $人 is rw, $phone) {
    $人.phone = $phone;
}

sub prefix:<📲>(人 $人) {
    print "Звоним +{$人.phone}";
    for 1..5 {
        sleep ½;
        '.'.print;
    }
    say "\n— Алло, {$人.name}?";
}

sub prefix:<🔊>(人 $人) {
    $人.say
}

my $X = 👨'Иван Петров';
my $Y = 👩'Лиза Смирнова';

$X ☎️ +79031234567;

🔊$X;
🔊$Y;

📲 $X;

Запускаем программу:

class-emoticons (1)

13. Создание своих операторов в Perl 6, часть 1

Perl 6 позволяет создавать кастомные операторы. По сути это обычная функция с необычным именем. Мы рассмотрим типы операторов с следующий раз, а сегодня создадим простой префикс.

Префиксный оператор — это оператор, который стоит перед объектом (переменной, строкой, и т. д.). Пример префиксного оператора — унарный минус или префиксный инкремент:

-$x;
++$x;

Давайте создадим оператор §, который просто превращает строку в строку из заглавных букв.

sub prefix:<§>($str) {
    $str.uc
}

Синтаксис похож на создание обычной функции, но надо указать тип оператора (prefix в нашем случае) и, собственно, сам оператор. Унарный оператор требует одного операнда, который здесь передается как параметр функции.

Попробуем применить только что созданный оператор (прямо в той же программе):

say §'hello, world!';

На печати появляется HELLO, WORLD!, что и требовалось.

Допускается включать фантазию и создавать не только текстовые операторы, например:

sub prefix:<🔊>(Str $str) {
    $str.uc
}
say 🔊'hello, world!';

Тема по созданию операторов еще не исчерпана, до встречи в одном из следующих выпусков!

12. rw, copy, readonly и raw в Perl 6

Вчера мы говорили об обратном слеше, который связывает парметры функции с данными, переданными при вызове. Сегодня мы продолжаем тему и поговорим о тех модификаторах (trait), которыми могут быть снабжены параметры.

Начнем с простого кода:

sub f($x) {
    $x++;
    say $x;
}

my $v = 42;
f($v);
say $v;

Этот код вполне бы работал в Perl 5.20 (если добавить use feature 'signatures'), но в Perl 6 он завершается с ошибкой:

Cannot resolve caller postfix:<++>(Int); the following candidates
match the type but require mutable arguments:
    (Mu:D $a is rw)
    (Int:D $a is rw)

The following do not match for other reasons:
    (Bool:D $a is rw)
    (Bool:U $a is rw --> Bool::False)
    (Mu:U $a is rw)
    (Num:D $a is rw)
    (Num:U $a is rw)
    (int $a is rw)
    (num $a is rw --> num)
  in sub f at args-1.pl line 2
  in block  at args-1.pl line 7

Сообщение об ошибке большое, но не сообщает о главном: по умолчанию аргументы функции разрешены только для чтения. Если убрать инкремент $x++, то все заработает:

42
42

Параметры в сигнатуре функции могут содержать дополнительные пометки со словом is. Если пометки нет, это все равно что есть is readonly, и, конечно же, понятно, что такую переменную изменить нельзя:

sub f($x is readonly) {
    # $x++;
    say $x;
}

Хотите что-то менять — передавайте копию переменной (is copy) или разрешайте ее изменять явно (is rw).

sub f($x is copy) {
    $x++;
    say $x;
}

sub g($x is rw) {
    $x++;
    say $x;
}

my $v = 42;
f($v);  # 43
say $v; # 42

g($v);  # 43
say $v; # 43

Понятно, что если передать константу, то изменить ее не получится:

f(42); # 43
g(42); # ошибка

Ошибка сообщает о том, что функция получила целое значение вместо изменяемой переменной (вполне себе сочетаемые слова).

Parameter '$x' expected a writable container, but got Int value
    in sub g at args-1.pl line 6
    in block  at args-1.pl line 19

Наконец, атрибут is raw это то же что и \, но только при этом переменные не лишаются сигила:

sub h($x is raw) {
    $x++;
    say $x;
}

my $n = 42;
h($n);   # 43
say $n;  # 43
# h(42); # ошибка

Как видите, возможностей весьма много, но это лишь часть того, на что способны сигнатуры функций в Perl 6.

11. Что такое \ в Perl 6

В перле есть три основных сигила — $, @ и %. Сюда еще можно добавить & и \ и несколько вариантов твигилов типа $? или $*. Сегодня же поговорим только об обратном слеше.

Это довольно нетипичная для обычного программирования штука, которая, однако, очень широко применятся во внутренностях Rakudo Perl 6. Рассмотрим пример:

sub add(\a, \b) {
    a + b
}

my $a = 10;
my $b = 20;
say add($a, $b); # 30

say add(3, 4);   # 7

На что здесь следует обратить внимание. Во-первых, параметры функции — переменные без сигила. Код для вычисления суммы двух значений — a + b, совсем не как обычно принято в перле: $a + $b.

Дальнейший код, казалось бы, не содержит никаких подводных камней. Однако, все меняется, если функция попытается изменить свои аргументы:

sub add(\a, \b) {
    a++;
    b++;
    return a + b;
}

Использование такой функции с переменными продолжает работать:

my $a = 10;
my $b = 20;
say add($a, $b); # 32
say $a;          # 11
say $b;          # 21

Переменные, однако, изменились после возвращения из функции. То есть в данном случае слеш похож по действию на ссылку в Perl 5.

Теперь попробуем вызвать функцию напрямую с константами:

say add(3, 4);

Эта короткая строка не то что не выполняется, но и выдает довольно объемное сообщение об ошибке:

Cannot resolve caller postfix:<++>(Int); the following candidates
match the type but require mutable arguments:
    (Mu:D $a is rw)
    (Int:D $a is rw)

The following do not match for other reasons:
    (Bool:D $a is rw)
    (Bool:U $a is rw --> Bool::False)
    (Mu:U $a is rw)
    (Num:D $a is rw)
    (Num:U $a is rw)
    (int $a is rw)
    (num $a is rw --> num)
  in sub add at bind-1.pl line 2
  in block  at bind-1.pl line 13

Обратный слеш связывает аргумент с объектом, в данном случае, с константой, которую функция попыталась изменить. Это оказалось невозможно, поэтому и произошла ошибка.

Завтра мы продолжим с этого места и поговорим о том, как записать \ другими словами.

10. Приемы отладки в Perl 6

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

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

say

Самое простое — функция say или одноименный метод, которые печатают простые объекты в довольно удобном виде:

my $str = 'Hello, World';
my $int = 42;
my $rat = ¾;
my @array = <alpha beta>;
my %hash = GB => 'London', FR => 'Paris';

say $str;   # Hello, World
say $int;   # 42
say $rat;   # 0.75
say @array; # [alpha beta]
say %hash;  # {FR => Paris, GB => London}

$str.say;   # Hello, World
$int.say;   # 42
$rat.say;   # 0.75
@array.say; # [alpha beta]
%hash.say;  # {FR => Paris, GB => London}

Этот же метод вполне пригоден и для классов:

class C {
    has $.x;
}
my $c = C.new(x => 10);

say $c; # C.new(x => 10)
$c.say; # C.new(x => 10)

perl

Чуть более изысканно — вызывать метод perl, возвращающий строку, которая теоретически является валидным кодом на Perl 6. Посмотрим, как это работает на примере тех же объектов:

say $str.perl;   # "Hello, World"
say $int.perl;   # 42
say $rat.perl;   # 0.75
say @array.perl; # ["alpha", "beta"]
say %hash.perl;  # {:FR("Paris"), :GB("London")}

say $c.perl;     # C.new(x => 10)

dd

В Rakudo Perl 6 (но не в самом языке Perl 6) есть функция dd, которая может использоваться в двух качествах. Во-первых, как дампер объектов:

dd $str;   # Str $str = "Hello, World"
dd $int;   # Int $int = 42
dd $rat;   # Rat $rat = 0.75
dd @array; # Array @array = ["alpha", "beta"]
dd %hash;  # Hash %hash = {:FR("Paris"), :GB("London")}
dd $c;     # C $c = C.new(x => 10)

Обратите внимание, что все переменные были созданы без ограничения на тип данных, но dd печатает и тип фактически находящихся в переменных данных.

Если же вызвать dd без аргументов, то она скажет, где находится. Например:

sub add($x, $y) {
    dd;             # sub add($x, $y)
    return $x + $y;
}

dd;                 # block <init>()
say add(1, 2);      # 3

WHAT

Метод WHAT — один из самых простых способов интроспекции объектов, он возвращает название типа данных (или класса), хранящихся в переменной:

say $str.WHAT;   # (Str)
say $int.WHAT;   # (Int)
say $rat.WHAT;   # (Rat)
say @array.WHAT; # (Array)
say %hash.WHAT;  # (Hash)
say $c.WHAT;     # (C)

Пока на сегодня все. До завтра!