Zum Abschluss der kleinen Blogpost-Serie ein Artikel der noch ein paar Änderungen aufsammelt, die nicht in die anderen Artikel gepasst haben.
Fangen wir mit einer Kleinigkeit an: Es gibt eine neue (zusätzliche) Syntax um Oktalzahlen in Perl-Code zu schreiben:
my $file_permissions = 0o755;
chmod $file_permissions, '/tmp/test.pl';
say sprintf "%d", $file_permissions; # 493
Für die Verwendung von Oktalzahlen gibt es mehrere Gründe. Bisher konnte man Oktalzahlen einfach mit 0
beginnen, also
my $file_permissions = 0755;
chmod $file_permissions, '/tmp/test.pl';
say sprintf "%d", $file_permissions; # 493
Das hat aber einen großen Nachteil: Gerade für Perl-Einsteiger ist nicht gleich erkennbar dass das eine Oktalzahl ist. Nicht nur einmal habe ich solchen Code gesehen:
my %hash = (
001 => 'eins',
010 => 'zehn',
100 => 'hundert',
);
Hier sollten in der Regel die führenden Nullen einfach zur Formatierung der Schlüssel verwendet werden. Aber was liefert ein
say "$_ => $hash{$_}" for sort keys %hash;
Etwas anderes als manche vielleicht vermuten würden:
1 => eins
100 => hundert
8 => zehn
Ups.
Die 0o... Schreibweise fügt sich auch besser in die bestehende Syntax für Hexadezimal- und Binärzahlen ein:
my $hex = 0xdeadaffe;
my $bin = 0b100;
Das nächste Thema ist ein ganz Kleines, aber eines auf das ich mich richtig freue: Es wird möglich sein, bei einer Iteration in einer for-Schleife mehr als nur ein Element aus einer Liste zu holen. Eine Standard-*for*-Schleife:
my @numbers = ( 1 .. 16 );
for my $nr ( @numbers ) {
say "$nr";
}
Die Aufgabe ist jetzt, diese Liste in vier Reihen zu je vier Zahlen auszugeben. Also nimmt man eine Laufvariable und bricht die Zeile nach jeweils 4 Elementen selbst um:
my @numbers = ( 1 .. 16 );
my $cnt = 1;
for my $nr ( @numbers ) {
print "$nr ";
print "\n" if $cnt++ % 4 == 0;
}
Einfacher geht das jetzt in Perl 5.36:
my @numbers = ( 1 .. 16 );
for my ($first, $second, $third, $fourth) ( @numbers ) {
say "$first $second $third $fourth";
}
Das Feature ist aber noch als experimentell markiert. Hier jetzt aber mal die Aufforderung: Nutzt auch experimentelle Features - auch in produktivem Code. Experimentell heißt nicht, dass man es nicht nutzen soll, sondern dass sich an der Implementierung ein paar Sachen ändern können. In vielen Fällen verlässt das Feature aber unverändert oder nur mit minimal Änderungen den experimentellen Status. Eine schöne Übersicht über die Experimente gibt es übrigens in der perlexperiment-Dokumentation.
Das abschließende Thema sind defer-Blöcke. Diese Blöcke kann man an jeder Stelle im Programmcode definieren; sie werden aber nicht gleich ausgeführt, sondern erst beim Verlassen des Gültigkeitsbereichs.
Ein kleines Beispiel:
use feature 'defer';
{
say "This happens first";
defer { say "This happens last"; }
say "And this happens inbetween";
}
Auch wenn der defer-Block in Zeile 5 vor dem say in Zeile 7 definiert wurde, wird dieser Gültigkeitsbereich in Zeile 8 verlassen wird. Die Ausgabe ist also
This happens first
And this happens inbetween
This happens last
Solche defer-Blöcke eignen sich sehr gut, um möglichst früh festzulegen, was später mal passieren soll. Ein Beispiel: Nach dem Aufbau einer Datenbankverbindung möchte man schon direkt sagen, dass bei Verlassen des Blocks die Verbindung abgebaut werden soll (und vielleicht noch weitere Dinge gemacht werden sollen) .
use feature 'defer';
{
my $dbh = DBI->connect( ... ) or die "Cannot connect";
defer { $dbh->disconnect; }
my $sth = $dbh->prepare( ... ) or die "Cannot prepare";
defer { $sth->finish; }
#...
}
Hier muss man nicht erst zig Seiten an Code runterscrollen, um zu erkennen, dass auch an das disconnect gedacht wurde. Es steht direkt bei dem Verbindungsaufbau.
Die defer-Blöcke werden in umgekehrter Reihenfolge ihrer Definition ausgeführt.
Perl 5.36 wird noch einiges mehr bringen als das, was in den vergangenen Blogartikeln gezeigt wurde. Wir freuen uns schon auf das neue Release und all die Änderungen, die damit einhergehen.
Permalink: /2022-05-25-auf-dem-weg-zu-perl-536-a-gesammelte-werke
Mit Perl 5.36 gibt es ein neues Pragma: builtin. Damit lassen sich neue Hilfsfunktionen in das Skript/Modul importieren. Derzeit bietet das Pragma folgende Hilfsfunktionen:
use v5.35;
use builtin qw(true false is_bool);
no warnings 'experimental::builtin';
my $true = true;
my $false = false;
say is_bool( $true );
say is_bool( $false );
Aktuell ist das Pragma als experimentell eingestuft. Beim Einbinden des Pragmas muss angegeben werden, welche Funktionen importiert werden sollen (alternativ kann man bei den Aufrufen einfach den vollqualifizierten Namen angeben, z.B. builtin::true().
true und false erstellt jeweils Werte, die im boolschen Kontext wahr bzw. unwahr liefern. In Strings und/oder Berechnungen werden aber die Standardwerte
für wahr/*unwahr* genommen: 1 bzw. "" (Leerstring).
Es gibt einen Unterschied zu den Werten, die man bisher typischerweise für die boolschen Werte verwendet hat: In den Interna der Variablen wird nun zur Laufzeit gespeichert, dass es sich um boolsche Werte handelt:
use Devel::Peek;
my $true = builtin::true;
my $false = builtin::false;
Dump( $true ); Dump( $false );
Liefert
SV = PVNV(0x5653938f9380) at 0x56539391f968
[...]
PV = 0x565392196bc4 "1" [BOOL PL_Yes]
[...]
SV = PVNV(0x5653938f93a0) at 0x56539391f938
[...]
PV = 0x565392196bc3 "" [BOOL PL_No]
[...]
Man sieht hier den Zusatz [BOOL PL_{Yes|No}]. Diese Zusatzinformation wird auch von builtin::is_bool ausgewertet. Damit kann man unterscheiden, ob die 1
ein boolscher Wert ist oder einfach die Zahl 1
:
my $zahl = 1;
my $wahr = builtin::true;
print sprintf '$zahl ist bool: %s, $wahr ist bool: %s',
builtin::is_bool( $zahl ),
builtin::is_bool( $wahr );
mit der Ausgabe
$zahl ist bool: , $wahr ist bool: 1
Auf Referenzen arbeiten einige Hilfsfunktionen:
Diese Funktionen sind auch in Scalar::Util verfügbar, deshalb zeige ich hier nur die – in meinen Augen – wichtigsten Funktionen weaken, blessed und reftype.
Mit blessed kann man herausfinden, ob eine Variable eine ge*blessed*e Referenz (sprich ein Objekt) ist. Ist das der Fall, wird der entsprechende Paketname zurückgeliefert:
use builtin qw(blessed);
no warnings 'experimental::builtin';
use Math::BigInt;
my $int = Math::BigInt->new(2022);
if ( blessed $int ) {
say '$int is blessed';
say "package: ", blessed $int;
}
liefert
$ perl blessed.pl
$int is blessed
package: Math::BigInt
Mit reftype bekommt man den Namen der Datenstruktur, auf die die Referenz verweist. Die meisten werden die Funktion ref kennen:
my $array_ref = [];
say ref( $array_ref ); # liefert ARRAY
Soweit so gut. Sobald es aber ein Objekt ist, wird nicht der Name der Datenstruktur ausgegeben, sondern der Name des Pakets:
my $array_object = bless [], 'Array';
say ref( $array_object ); # liefert Array, also den Paketnamen
reftype liefert in jedem Fall den Namen der Datenstruktur:
my $array_object = bless [], 'Array';
say reftype( $array_object ); # liefert ARRAY
Werden komplexe Datenstrukturen aufgebaut, kann es schnell passieren, dass man zirkuläre Referenzen aufbaut:
my %hash_eins;
my %hash_zwei = ( eins => \%hash_eins );
$hash_eins{zwei} = \%hash_zwei;
Damit hat man ein Speicherleck erzeugt. Perl nutzt einen Referenzzähler, um Speicher freizugeben. Und der kann hier nie auf 0 gehen, da in einer zirkulären Referenz immer A auf B verweist und B auf A.
In so einem Fall kann man weaken nutzen. Damit wird der Referenzzähler der Variable nicht hochgezählt:
my %hash_eins;
my %hash_zwei = ( eins => \%hash_eins );
$hash_eins{zwei} = \%hash_zwei;
builtin::weaken( $hash_eins{zwei} );
Zu diesem Problem werden wir noch einen weiteren Blogartikel schreiben.
Eine kleine Funktionalität, die aber auch bei den Entwicklern von Perl viel Diskussionen hervorgerufen hat. Es gibt auf CPAN etliche Implementierungen davon. Leerzeichen am Anfang und am Ende eines Strings entfernen.
Warum gab es diese Diskussionen? Es ging hauptsächlich darum, was das trimmen genau machen soll. Einfach nur Leerzeichen oder noch andere Whitespaces? Soll der Nutzer die Möglichkeit haben, die zu entfernenden Zeichen selbst festzulegen? Soll das ganze Inplace (wie s///) passieren oder soll der veränderte Wert zurückgegeben werden?
Mit trim werden die Whitespaces am Anfang und am Ende eines Strings entfernt und der veränderte Wert wird zurückgegeben:
use builtin qw(blessed);
no warnings 'experimental::builtin';
my $t = "\t \ntest \n ";
say ">>",$t,"<<";
my $trimmed = builtin::trim($t); s
ay ">>$trimmed<<"
liefert die Ausgabe
>>
test
<<
>>test<<
Im Laufe der Zeit werden sicher noch etliche nützliche Hilfsfunktionen im builtin::-Namensraum landen. Schon in Perl 5.36 sind viele Helferlein enthalten, die schon so oft vermisst wurden. Die Vorfreude auf das neue Release wächst.
Permalink: /2022-05-20-auf-dem-weg-zu-perl-536-builtin
Es ist nicht schön, wenn man eine Anwendung hat, die vielleicht mittendrin einfach aufhört zu laufen. Vielleicht ist die Anwendung in einen Fehler gelaufen und vielleicht gibt es keine ordentliche Fehlermeldung. Woran hat es gelegen? An welcher Stelle ist der Fehler aufgetreten?
In Perl nutzt man häufig eval {} , um Fehler abzufangen und eine ordentliche Fehlerbehandlung zu machen. Das hat aber auch Schwächen, so steckt der Fehler in der Spezialvariablen $@ und je nach Situation könnte diese Variable vor der Fehlerbehandlung wieder geleert werden.
Auf CPAN gibt es mehrere Module, die das try/catch-Konstrukt aus anderen Programmiersprachen als Perl-Modul umsetzen. Seit Perl 5.34 gibt es dieses Werkzeug direkt mit dem Perl-Kern und mit Perl 5.36 noch ein weitere Verbesserung. Das ist allerdings noch als experimentell gekennzeichnet.
Schauen wir uns den Standard-Fall mal an:
eval {
die "Help!";
};
if ( $@ ) {
warn "An error occured: $@";
}
In Zeile 2 wird ein die ausgeführt, was zu einem Programmabbruch führen würde. Dank des Block-eval wird dieser Abbruch aber abgefangen und es kann eine ordentliche Fehlerbehandlung durchgeführt werden.
In das try/catch überführt, sieht das so aus:
use feature 'try';
no warnings 'experimental::try';
try {
die 'This died';
}
catch ( $error ) {
warn "The code inside 'try' died with error: '$error'";
}
Der try-Block sieht genauso aus wie beim eval. Allerdings schließt sich hier direkt ein catch-Block an, dem der Fehler aus dem try-Block übergeben wird. Dieser Fehler landet in $error.
Wird bei dem die ein Fehlerobjekt übergeben, landet genau dieses Objekt auch in $error:
use feature 'try';
no warnings 'experimental::try';
package ErrorObject { use Moo; has message => ( is => 'ro' ) }
try {
die ErrorObject->new( message => 'An error occured' );
}
catch ( $error ) {
warn sprintf "The code inside 'try' died with error: '%s'",
$error->message;
}
In Perl 5.36 kommt die Möglichkeit hinzu, einen finally-Block zu definieren. Dieser wird auf jeden Fall ausgeführt – egal, ob ein Fehler aufgetreten ist oder nicht. Außerdem ist es egal, ob in dem catch-Block ein exit aufgerufen wird oder nicht.
Dieser Block kann daher gut für abschließende Schritte verwendet werden, die auf jeden Fall ausgeführt werden sollen:
use feature 'try';
no warnings 'experimental::try';
package ErrorObject { use Moo; has message => ( is => 'ro' ) }
try {
die ErrorObject->new( message => 'An error occured' );
}
catch ( $error ) {
warn sprintf "The code inside 'try' died with error: '%s'",
$error->message;
exit;
}
finally {
print "clean up...";
}
Permalink: /2022-05-12-auf-dem-weg-zu-perl-536-trycatchfinally
Mittels use v5.<version> können Features und Standardeinstellungen für die angegebene Perl-Version geladen werden. Und es ist die minimal notwendige Perl-Version. Ein use v5.10 verlangt, dass das Programm mindestens mit Perl 5.10 ausgeführt wird. Darüber hinaus wird zum Beispiel das Feature say aktiviert.
Mit use v5.36 ändern sich einige Dinge, die in den folgenden Absätzen beschrieben werden.
Es ist seit vielen Jahren bewährte Praxis, dass zu den ersten Zeilen eines jeden Programms oder Moduls die Zeilen use strict; und use warnings; gehören sollen. Mit use v5.36 ist das nicht mehr notwendig, denn damit wird beides automatisch aktiviert (strict wird schon seit längerem auf diese Weise aktiviert).
use v5.35;
my $s = 'test';
$s += 1;
Gibt diese Warnung aus:
Argument "test" isn't numeric in addition (+)
Konstruktewerden zu echten Fehlern
Es gibt Dinge, die in Perl möglich sind aber schon seit vielen Jahren nicht mehr empfohlen werden. Drei dieser Dinge werden jetzt zu echten Fehlern. Ohne das use v5.36 laufen die noch, aber von der Verwendung rate ich ab.
Wer auch mit use v5.36 diese Konstrukte verwenden möchte, muss das explizit über use feature "feature_name" tun.
Ich muss gestehen, dass ich diese Konstrukt noch nie in produktivem Code gesehen geschweige denn verwendet habe.
my %x;
$x{1,'talk'} = 'Perl Features';
print $x{1,'talk'};
Wie man sieht, ist hier der Hash kein einzelner Wert sondern eine Liste an Werten. Mit use v5.36 ist das nicht mehr erlaubt und die Fehlermeldung
Multidimensional hash lookup is disabled
erscheint.
Für diejenigen, die es interessiert: Bei diesen multidimensionalen Hashes werden die Werte der Liste zu einem Schlüssel zusammengefügt, so dass es ein normaler
Hash ist. Die Werte werden dabei mit \x1C (File Separator) konkateniert, so dass man theoretisch auf den oben gezeigten Hasheintrag auch über
print $x{"1\x1Ctalk"};
zugreifen kann.
Diese Schreibweise dürfte Programmierern mit Erfahrung in anderen Programmiersprachen bekannt vorkommen:
my $object = new Klasse;
Eigentlich sollte
my $object = Klasse->new;
verwendet werden.
Die erste Schreibweise nennt man indirekte Methodenaufrufe. Der Code kann so funktionieren wie es gewünscht ist, muss aber nicht. Das Problem wird vielleicht mit etwas Code deutlicher:
use v5.10;
package Klasse {
sub new { return bless {}, shift }
sub test { return "test" }
};
sub hallo { return "hallo" };
my $object = new Klasse;
say $object;
say hallo $object;
my $test = test $object;
say $test;
say test $object;
Was passiert hier ab der Zeile 11?
In den Zeilen davor wird nur etwas Vorbereitung betrieben. Zeile 1 wird benötigt, damit das say zur Verfügung steht. Und in den Zeilen 3 bis 6 wird ein package definiert, das die zwei Subs new und test bereitstellt. Hier ist das package eine Klasse. In Zeile 8 wird noch eine Subroutine hallo definiert, die zum Hauptprogramm
gehört.
Schon Gedanken dazu gemacht, was in den restlichen Zeilen des Codes passiert? Die Ausgabe sieht so aus:
Klasse=HASH(0x55e4b7c81340)
hallo
test
say() on unopened filehandle test at ...
In Zeile 10 wird die Funktion new des Pakets Klasse aufgerufen. Diese gibt ein Objekt zurück. Die Zeile 1 der Ausgabe bestätigt das. Funktioniert.
In Zeile 13 wird die Funktion hallo des Hauptprogramms ausgeführt und diese bekommt das Objekt als ersten Parameter übergeben (das sieht man jetzt nicht an der Ausgabe, kann aber durch eine kleine Änderung am Code selbst überprüft werden). Funktioniert.
In Zeile 15 wird die Methode test des Objekts aufgerufen, das Ergebnis (test
) landet in der Variable $test und diese wird in Zeile 16 ausgegeben. Funktioniert.
Zeile 18 provoziert einen Fehler. Offensichtlich denkt perl, dass test ein Dateihandle ist (siehe auch nächstes Konstrukt
), und nicht die Methode test des Objekts. Das heißt, ich muss bei dieser Schreibweise aufpassen, in welchem Umfeld ich die Methode aufrufen will.
Und was passiert wenn in Zeile 9 noch eine Subroutine test (sub test { "test2"} ) eingefügt wird? In diesem Fall wird perl diese Funktion in den Zeilen 15 und 18 genau diese Funktion ausführen und die Ausgabe wäre
Klasse=HASH(0x55e4b7c81340)
hallo
test2
test2
Es gibt noch mehr Fallen. Aus diesem Grund sind diese indirekten Methodenaufrufe mit use v5.36 nicht mehr erlaubt. Allerdings kann perl nur die indirekten Methodenaufrufe wie in Zeile 10 erkennen und es kommt zu der Fehlermeldung
Bareword "Klasse" not allowed while "strict subs" in use
Die Probleme oben verdeutlichen aber, warum grundsätzlich die Schreibweise mit -> verwendet werden soll. Denn damit weiß der Interpreter immer, welche Funktion/Methode ausgeführt werden muss.
In vielen Perl-Tutorials, die so im Internet zu finden sind, wird das Schreiben einer Datei mit folgendem Code (oder so ähnlich) gezeigt:
open FH, ">/tmp/datei.txt" or die $!;
print FH "Eine Zeile\n";
close FH;
Dieses FH ist ein sogenanntes Bareword Filehandle. Der Name kann frei gewählt werden. Für einen Einstieg in Perl oder in Einzeilern ist die Verwendung dieser Bareword Filehandles auch ganz gut. Aber wer etwas Erfahrung mit Perl gesammelt hat, sollte darauf verzichten und zu lexikalischen Dateihandles übergehen:
open my $fh, ">", "/tmp/datei.txt" or die $!;
print $fh "Eine Zeile\n";
close $fh;
Ein Vorteil dieser lexikalischen Dateihandles haben wir beim vorherigen Konstrukt gezeigt. Was wenn es zufällig eine Subroutine mit dem Namen des *Bareword*s gibt? Es gibt aber noch weitere Vorteile: Die lexikalischen Dateihandles werden automatisch geschlossen, wenn sie den Gültigkeitsbereich verlassen (auch wenn man schon allein wegen der Fehlerbehandlung selbst das close machen sollte). Und sie sind eben lexikalisch, also nicht global.
Die Bareword Filehandles sind global und können so zu Seiteneffekten führen. Ein Beispiel:
use warnings;
read_data();
sub read_data {
open FH, '</tmp/data.txt' or die $!;
while ( my $line = <FH> ) {
print $line;
add_to_log( $line ) if $line =~ m{error};
}
close FH;
}
sub add_to_log {
open FH, '>/tmp/log.txt' or die $!;
print FH $_[0];
close FH;
}
Wenn /tmp/data.txt eine Zeile mit error
enthält, sieht die Ausgabe so aus:
ein
error
readline() on closed filehandle FH at ...
Das globale Filehandle wurde also in einer Subroutine geschlossen, bevor alle Zeilen der Datei in der Ursprungssubroutine gelesen werden konnten.
Benutzt man die Bareword Filehandles mit use v5.36, gibt es eine entsprechende Fehlermeldung:
Bareword filehandle "FH" not allowed under 'no feature "bareword_filehandles"' at ...
Einige Standard-*Bareword Filehandles* wie STDIN, STDOUT, STDERR und DATA werden auch mit use v5.36 funktionieren.
Permalink: /2022-05-06-auf-dem-weg-zu-perl-536-a-anderungen-mit-use-v536
Nicht einmal 1 Monat, dann wird es die nächste Version von Perl 5 geben: Perl 5.36. Um die Wartezeit etwas zu verkürzen, werden wir hier ein paar Neuerungen vorstellen. Der erste Teil hat dann aber etwas zum Thema, das gar nicht mehr so neu ist: (Methoden-)Signaturen. Schon seit Perl 5.20 (also rund acht Jahre) gibt es die Signaturen. Aber jetzt endlich sind sie nicht mehr als experimentell
gekennzeichnet.
Mit den Signaturen kann der Code übersichtlicher gestaltet werden und man automatisch eine Überprüfung der Anzahl der übergebenen Parameter dabei.
Der einfachste Fall sind verpflichtende Parameter:
use v5.35; # aktiviert auch strict und warnings
crawl( 'https://perl-academy.de' );
sub crawl ($url) {
say "URL: $url";
# hole die Seite und extrahiere die Links
# siehe Beispielcode im Git-Repository
}
Hier hat die Subroutine crawl genau einen Pflichtparameter – $url. Die Variable muss nicht extra deklariert werden und diese ist nur in der Subroutine gültig. In der Subroutine selbst kann ganz normal mit der Variablen gearbeitet werden.
In diesem Beispiel ersetzt das
sub crawl ($url) {
}
mehr oder weniger nur ein
sub crawl {
my ($url) = @_;
}
Sieht erst einmal nach nicht viel aus. Mit der Verwendung der Signaturen gibt es aber eine Prüfung der Anzahl an übergebenen Parameter. Der Aufruf crawl() erzeugt dann die Fehlermeldung
Too few arguments for subroutine 'main::crawl' (got 0; expected 1)
und der Aufruf crawl('https://perl-academy.de', 1) erzeugt die Fehlermeldung
Too many arguments for subroutine 'main::crawl' (got 2; expected 1)
Möchte man etwas flexibler in den Aufrufen sein, muss also etwas an den Signaturen geändert werden. Eine Möglichkeit ist, slurpy Parameter zu nutzen. Soll crawl beliebig viele Parameter akzeptieren, kann man
sub crawl ($url, @more_parameters) {
}
nutzen. Damit landet der erste übergebene Parameter in $url und alle weiteren Parameter in @more_parameters. Es kann auch ein Hash benutzt werden:
sub crawl ($url, %opts) {
}
Damit landet bei einem Aufruf mit crawl('https://perl-academy.de', max_redirects => 2) die URL in $url und im Hash %opts gibt es den Schlüssel max_redirects mit dem Wert 2.
Aber diese beiden Möglichkeiten sind nicht immer die beste Wahl, weil dann unterschiedliche Parameter in einem Array landen. Deshalb gibt es auch die Möglichkeit, mittels default-Werten die Parameter optional zu machen und sie mit einem vorgegebenen Wert zu belegen:
sub crawl ($url, $max_redirects = 2) {
}
Bei einem Aufruf mit crawl('https://perl-academy.de', 5) ist der Wert von $max_redirects natürlich 5, bei einem Aufruf mit crawl('https://perl-academy.de' ) ist der Wert der Variablen 2.
Der default-Wert muss nicht nur eine Zahl oder ein String sein, sondern kann ein Subroutinen-Aufruf sein, vorherige Parameter können verwendet werden und auch ein do{}-Block ist möglich:
sub crawl ($url, $max_redirects = get_config('max_redirects') ) {
}
sub crawl ($url, $api_url = $url . '/api/v1' ) {
}
sub crawl ( $url, $max_redirects = do { warn "Using default value"; 2; } ) {
}
Es gibt noch die Möglichkeit, unbenannte Variablen zu nutzen, wenn man an der Verwendung von Werten nicht interessiert ist. Die Verwendung dieser unbenannten Variablen ist unter https://metacpan.org/release/SHAY/perl-5.35.11/view/pod/perlsub.pod#Signatures nachzulesen. Das würde diesen Blogartikel zu sehr ausdehnen und diese Variablen spielten bisher bei in meinem Code keine Rolle.
Was Signaturen nicht bietet, sind Prüfungen von Datentypen. Es wird also nicht geprüft, ob der übergebene Skalar eine Arrayreferenz, Hashreferenz oder einfach ein String ist. Das muss weiterhin selbst gemacht werden. Auch benannte Parameter (beispielsweise crawl( url => 'https://perl-academy.de') ) sind derzeit nicht möglich.
Aber schon die gezeigten Möglichkeiten können das Programmieren stark vereinfachen.
Der Beispielcode ist im Git-Repository unter https://os.perl-services.de/perl-academy/blog-codesamples/-/tree/main/2022/04/5_36_signaturen zu finden.