Existtenztest auf Coderef

Hallo zusammen,

gegeben folgendes Programm:

------------------------
#!/usr/bin/perl -w

use strict;

my $f = \&{'bla'};
$f->();
------------------------

Dieses stirbt erwartungsgemäß mit der Meldung:

Undefined subroutine &main::bla called at /tmp/test5.pl line 6.

Frage: Wie überprüfe ich Codereferenz $f daraufhin,
ob sie in den Wald zeigt oder nicht?

Grüße
Frank
--
Dipl.-Inform. Frank Seitz; http://www.fseitz.de/
Anwendungen für Ihr Internet und Intranet
Tel: 04103/180301; Fax: -02; Industriestr. 31, 22880 Wedel

Re: Existtenztest auf Coderef

Frank Seitz writes:

> Hallo zusammen,
>
> gegeben folgendes Programm:
>
> ------------------------
> #!/usr/bin/perl -w
>
> use strict;
>
> my $f = \&{'bla'};
> $f->();
> ------------------------
>
> Dieses stirbt erwartungsgemäß mit der Meldung:
>
> Undefined subroutine &main::bla called at /tmp/test5.pl line 6.
>
> Frage: Wie überprüfe ich Codereferenz $f daraufhin,
> ob sie in den Wald zeigt oder nicht?

defined &$f scheint zu funktionieren.

Gruß,
Slaven

--
Slaven Rezic - slaven rezic de

Dump a Tk canvas as an xfig file:
http://search.cpan.org/search?mode=module&query=Tk::CanvasFi g

Re: Existtenztest auf Coderef

Slaven Rezic wrote:
> Frank Seitz writes:
>>
>>gegeben folgendes Programm:
>>
>>------------------------
>>#!/usr/bin/perl -w
>>
>>use strict;
>>
>>my $f = \&{'bla'};
>>$f->();
>>------------------------
>>
>>Dieses stirbt erwartungsgemäß mit der Meldung:
>>
>>Undefined subroutine &main::bla called at /tmp/test5.pl line 6.
>>
>>Frage: Wie überprüfe ich Codereferenz $f daraufhin,
>>ob sie in den Wald zeigt oder nicht?
>
> defined &$f scheint zu funktionieren.

Danke, funktioniert. Unter perldoc -f defined ist das auch erwähnt.
Darauf wäre ich allerdings nie gekommen, da &$f ja eigentlich
ein Aufruf ist, der bei einer definierten Subroutine ja
durchaus undef liefern kann.

Als Argument von defined() wird &$f offenbar abweichend intpretiert.
Typisch Perl. Oder liegt dem eine Systematik zugrunde,
die ich nur nicht erkenne?

Grüße
Frank
--
Dipl.-Inform. Frank Seitz; http://www.fseitz.de/
Anwendungen für Ihr Internet und Intranet
Tel: 04103/180301; Fax: -02; Industriestr. 31, 22880 Wedel

Re: Existtenztest auf Coderef

Frank Seitz writes:

> Slaven Rezic wrote:
> > Frank Seitz writes:
> >>
> >>gegeben folgendes Programm:
> >>
> >>------------------------
> >>#!/usr/bin/perl -w
> >>
> >>use strict;
> >>
> >>my $f = \&{'bla'};
> >>$f->();
> >>------------------------
> >>
> >>Dieses stirbt erwartungsgemäß mit der Meldung:
> >>
> >>Undefined subroutine &main::bla called at /tmp/test5.pl line 6.
> >>
> >>Frage: Wie überprüfe ich Codereferenz $f daraufhin,
> >>ob sie in den Wald zeigt oder nicht?
> >
> > defined &$f scheint zu funktionieren.
>
> Danke, funktioniert. Unter perldoc -f defined ist das auch erwähnt.
> Darauf wäre ich allerdings nie gekommen, da &$f ja eigentlich
> ein Aufruf ist, der bei einer definierten Subroutine ja
> durchaus undef liefern kann.
>
> Als Argument von defined() wird &$f offenbar abweichend intpretiert.
> Typisch Perl. Oder liegt dem eine Systematik zugrunde,
> die ich nur nicht erkenne?
>

Bei normalen Subroutinen gibt es auch die selbe Möglichkeit der
Prüfung:

if (defined &subroutine) ...

Dort bin ich nie auf die Idee gekommen, dass man damit

if (defined subroutine) ...

meinen könnte, also einen Aufruf von "subroutine" und die Prüfung des
Rückgabewertes auf Definiertheit. Bei mir hat also DWIM
funktioniert...

Gruß,
Slaven

--
Slaven Rezic - slaven rezic de
BBBike - Routenplaner für Radfahrer in Berlin
WWW-Version: http://www.bbbike.de
Offline-Version für Unix,Mac,Windows: http://bbbike.sourceforge.net

Re: Existtenztest auf Coderef

Slaven Rezic wrote:
> Frank Seitz writes:
>>
>>Als Argument von defined() wird &$f offenbar abweichend intpretiert.
>>Typisch Perl. Oder liegt dem eine Systematik zugrunde,
>>die ich nur nicht erkenne?
>
> Bei normalen Subroutinen gibt es auch die selbe Möglichkeit der
> Prüfung:
>
> if (defined &subroutine) ...
>
> Dort bin ich nie auf die Idee gekommen, dass man damit
>
> if (defined subroutine) ...
>
> meinen könnte, also einen Aufruf von "subroutine" und die Prüfung des
> Rückgabewertes auf Definiertheit. Bei mir hat also DWIM
> funktioniert...

Ich finde es unlogisch. Diesen Unterschied kann man sich auch
nicht herleiten, den kann man offenbar nur wissen (oder eben nicht).

Der folgende Code verdeutlicht vielleicht die Kuriosität:

#!/usr/bin/perl -w

use strict;

sub f { return undef }
print defined &f? 'defined': 'undefined',"\n";

my $r = &f;
print defined $r? 'defined': 'undefined',"\n";

__END__
defined
undefined

Grüße
Frank
--
Dipl.-Inform. Frank Seitz; http://www.fseitz.de/
Anwendungen für Ihr Internet und Intranet
Tel: 04103/180301; Fax: -02; Industriestr. 31, 22880 Wedel

Re: Existtenztest auf Coderef

Frank Seitz:

> Der folgende Code verdeutlicht vielleicht die Kuriosität:

Meinst du?

> sub f { return undef }
> print defined &f? 'defined': 'undefined',"\n";
>
> my $r = &f;
> print defined $r? 'defined': 'undefined',"\n";

Da sehe ich nichts Unlogisches oder Kurioses.. Im ersten
Fall überprüfst du, ob es eine Subroutine namens "f" gibt -
da das der Fall ist, wird "defined" ausgegeben.

Im zweiten Fall rufst du die Subroutine f auf, weist ihren
Rückgabewert (undef) der Variablen "$r" zu, und es wird,
da ja $r nun "undef" enthält, ensprechend auch "undefined"
ausgegeben.

Wo ist der Widerspruch bzw. was willst du mit diesem
Beispiel beweisen?

LG, Ferry

--
Ing. Ferry Bolhar
Municipality of Vienna, Department 14
A-1010 Vienna / AUSTRIA
E-mail: bol@adv.magwien.gv.at

Re: Existtenztest auf Coderef

Ferry Bolhar wrote:
> Frank Seitz:
>>
>>Der folgende Code verdeutlicht vielleicht die Kuriosität:
>
> Meinst du?

Ja. Bin ich hier etwa der einzige, dessen Konsistenzempfinden
durch Perl noch nicht völlig vesaut ist? ;)

>>sub f { return undef }
>>print defined &f? 'defined': 'undefined',"\n";
>>
>>my $r = &f;
>>print defined $r? 'defined': 'undefined',"\n";
>
> Da sehe ich nichts Unlogisches oder Kurioses.. Im ersten
> Fall überprüfst du, ob es eine Subroutine namens "f" gibt -
> da das der Fall ist, wird "defined" ausgegeben.
>
> Im zweiten Fall rufst du die Subroutine f auf, weist ihren
> Rückgabewert (undef) der Variablen "$r" zu, und es wird,
> da ja $r nun "undef" enthält, ensprechend auch "undefined"
> ausgegeben.

Dass dies das Verhalten ist, ist mir klar.

> Wo ist der Widerspruch bzw. was willst du mit diesem
> Beispiel beweisen?

Nunja, ich bin der altmodischen Ansicht, dass man einem
Ausdruck halbwegs ansehen können sollte, was er bedeutet.
Bei "defined &f" gelingt mir das aber nicht, obwohl ich
die Bedeutung von "defined" als auch "&f" sehr
wohl kenne. In der Kombination bedeutet dieser Ausdruck etwas
völlig anderes als die Kombination der Einzelbedeutungen
und sowas finde ich für eine Programmiersprache
nunmal schädlich.

Grüße
Frank
--
Dipl.-Inform. Frank Seitz; http://www.fseitz.de/
Anwendungen für Ihr Internet und Intranet
Tel: 04103/180301; Fax: -02; Industriestr. 31, 22880 Wedel

Re: Existtenztest auf Coderef

* Ferry Bolhar [2006-07-10]:

Hallo Ferry,

> > sub f { return undef }
> > print defined &f? 'defined': 'undefined',"\n";
> >
> > my $r = &f;
> > print defined $r? 'defined': 'undefined',"\n";
> Wo ist der Widerspruch bzw. was willst du mit diesem
> Beispiel beweisen?

das in beiden Fällen »&f« verwendet wird, wenn es vor 'defined' benutzt
wird aber etwas anderes zurückliefert als ohne. Das 'defined' ändert
also die Bedeutung von '&f', die Funktion 'f' wird hier ja schlicht gar
nicht aufgerufen.

Ich finde das persönlich aber völlig akzeptabel, da die '&'-Notation eh
Perl4-Style ist und man sie aus diesem und einigen anderen Gründen nur
verwenden sollte, wenn man genau weiss was man macht. Wenn man es
trotdem ohne Nachzudenken benutzt, dann darf man sich auch nicht
wundern, wenn @_ plötzlich unvorhergesehene Parameter enthät.

Gruß
Christian

--
Wir wissen zwar nicht, wo wir hinwollen,
werden aber als erste dabei sein.
http://www.lackas.net/ Perl Delphi Linux MP3 Searchengines Domainchecker

Re: Existtenztest auf Coderef

Frank Seitz wrote

> Nunja, ich bin der altmodischen Ansicht, dass man einem
> Ausdruck halbwegs ansehen können sollte, was er bedeutet.
> Bei "defined &f" gelingt mir das aber nicht, obwohl ich
> die Bedeutung von "defined" als auch "&f" sehr
> wohl kenne. In der Kombination bedeutet dieser Ausdruck etwas
> völlig anderes als die Kombination der Einzelbedeutungen
> und sowas finde ich für eine Programmiersprache
> nunmal schädlich.

Warum dann nicht einfach etwas wie __PACKAGE__->can( 'foo' )? Perl hat
nicht wenige Bereiche, wo es davon abhaengt, wie man die Sprache nutzt.
Man siehe sich nur mal das Thema Kontext an.


p

--
That is not dead, which can eternal lie,
and with strange aeons even death may die.
-- H.P. Lovecraft

Re: Existtenztest auf Coderef

Robert 'phaylon' Sedlacek wrote:
> Frank Seitz wrote
>>
>>Nunja, ich bin der altmodischen Ansicht, dass man einem
>>Ausdruck halbwegs ansehen können sollte, was er bedeutet.
>>Bei "defined &f" gelingt mir das aber nicht, obwohl ich
>>die Bedeutung von "defined" als auch "&f" sehr
>>wohl kenne. In der Kombination bedeutet dieser Ausdruck etwas
>>völlig anderes als die Kombination der Einzelbedeutungen
>>und sowas finde ich für eine Programmiersprache
>>nunmal schädlich.
>
> Warum dann nicht einfach etwas wie __PACKAGE__->can( 'foo' )?

Weil ich eine Code-Referenz habe.

> Perl hat
> nicht wenige Bereiche, wo es davon abhaengt, wie man die Sprache nutzt.
> Man siehe sich nur mal das Thema Kontext an.

Gegen Kontextsensitivität habe ich nichts, wenn sie einem
allgemeinen Konzept folgt. Das scheint hier nicht der Fall zu sein.

BTW: Am Mi. ist Perl Mongers Treffen im Feuerstein (19 Uhr).
(wer aus HH und Umgebung ist, ist herzlich eingeladen)

Grüße
Frank
--
Dipl.-Inform. Frank Seitz; http://www.fseitz.de/
Anwendungen für Ihr Internet und Intranet
Tel: 04103/180301; Fax: -02; Industriestr. 31, 22880 Wedel

Re: Existtenztest auf Coderef

Frank Seitz:

> Frage: Wie überprüfe ich Codereferenz $f daraufhin, ob sie in den Wald
zeigt oder nicht?

"In den Wald" zeigt sie nie - sie zeigt allenfalls auf eine (noch) nicht
vorhandene Funktion, die man aber vor dem Aufruf noch anlegen könnte.

Slaven hat "defined" vorgeschlagen, das ist aber, wie du selbst erkannt
hast,
nicht immer eindeutig - es kann etwas definiert sein und dennoch einen
Wert "undef" enthalten bzw. zurückliefern. Für deinen Fall würde sich eher
"exists" anbieten:

print exists(&$f) ? "exists" : "doesn't exist";

dessen Argument du der Ordnung halber gar nicht mit Klammern (dh., als
"&$f()") aufrufen kannst. Daher kannst du hier sicher sein, dass tatsächlich
nur die Existenz der Funktion und nicht deren Rückgabewert geprüft wird.

Was deine Feststellungen zur Interpretation von

&$f;

angeht, so ist sie - wie so vieles in Perl - eben kontextspezifisch:
alleine,
oder auf der rechten Seite einer Zuweisung wird sie als Funktionsaufruf
interpretiert, aber als Argument von "defined" (und anderen Builtin-ins)
nur als "Wert" (Code Value) ansich.

LG, Ferry

--
Ing. Ferry Bolhar
Municipality of Vienna, Department 14
A-1010 Vienna / AUSTRIA
E-mail: bol@adv.magwien.gv.at

Re: Existtenztest auf Coderef

Frank Seitz wrote
> Gegen Kontextsensitivität habe ich nichts, wenn sie einem
> allgemeinen Konzept folgt. Das scheint hier nicht der Fall zu sein.

Gut, dann nehmen wir doch als Beispiel die split Sonderfaelle " " gegen
/ /. Ich wollte eher ausdruecken, dass die Verwendung solcher Idiome
fuer manche Projekte natuerlich nicht geeignet sind. Aber ich sehe
nicht, warum es der Sprache schaden wuerde.

> BTW: Am Mi. ist Perl Mongers Treffen im Feuerstein (19 Uhr).
> (wer aus HH und Umgebung ist, ist herzlich eingeladen)

Mal sehen ob ich Zeit habe, ich arbeite ja nur 2 Minuten davon entfernt.


p

--
The first rule of project mayhem is: you do not ask questions.
-- Fight Club

Re: Existtenztest auf Coderef

Ferry Bolhar wrote:
> Frank Seitz:
>>
>>Frage: Wie überprüfe ich Codereferenz $f daraufhin, ob sie in den Wald
>>zeigt oder nicht?
>
> "In den Wald" zeigt sie nie - sie zeigt allenfalls auf eine (noch) nicht
> vorhandene Funktion, die man aber vor dem Aufruf noch anlegen könnte.

Die Referenz zeigt zwar nicht so sehr in den Wald wie
ein Pointer in C in den Wald zeigen kann, aber immerhin führt
ihre Nutzung (Aufruf) zu einem Programmabbruch, was im
Endeffekt auf dasselbe hinausläuft, nur mit einer schöneren Meldung.

> Slaven hat "defined" vorgeschlagen, das ist aber, wie du selbst erkannt
> hast, nicht immer eindeutig - es kann etwas definiert sein und dennoch einen
> Wert "undef" enthalten bzw. zurückliefern.

Nein, der Vorschlag funktioniert. Er ist daher völlig in Ordnung.
Nur das Konstrukt finde ich unschön.

> Für deinen Fall würde sich eher
> "exists" anbieten:
>
> print exists(&$f) ? "exists" : "doesn't exist";
>
> dessen Argument du der Ordnung halber gar nicht mit Klammern (dh., als
> "&$f()") aufrufen kannst. Daher kannst du hier sicher sein, dass tatsächlich
> nur die Existenz der Funktion und nicht deren Rückgabewert geprüft wird.

Das dagegen funktioniert nicht!

> Was deine Feststellungen zur Interpretation von
>
> &$f;
>
> angeht, so ist sie - wie so vieles in Perl - eben kontextspezifisch:
> alleine,
> oder auf der rechten Seite einer Zuweisung wird sie als Funktionsaufruf
> interpretiert, aber als Argument von "defined" (und anderen Builtin-ins)
> nur als "Wert" (Code Value) ansich.

Wie schon gesagt: Gegen Kontextsensitivität habe ich nichts,
wenn sie einem allgemeinen Konzept folgt. Wenn ich bei jedem Builtin
damit rechnen muss, dass die Argumente abweichend von ihrer Normalbedeutung
interpretiert werden, bekomme ich in der Programmierung ein Problem.
Soo schlimm ist es ja aber glücklicherweise nicht.
Ich wüsste jetzt kein vergleichbares Beispiel in Perl.
Split / / vs. ' ' ist m.E. keins.

Grüße
Frank
--
Dipl.-Inform. Frank Seitz; http://www.fseitz.de/
Anwendungen für Ihr Internet und Intranet
Tel: 04103/180301; Fax: -02; Industriestr. 31, 22880 Wedel

Re: Existtenztest auf Coderef

Frank Seitz wrote
> Wenn ich bei jedem Builtin
> damit rechnen muss, dass die Argumente abweichend von ihrer Normalbedeutung
> interpretiert werden, bekomme ich in der Programmierung ein Problem.

Du musst damit rechnen, dass die Sprache so funktioniert, wie sie
dokumentiert ist. Nicht mehr und nicht weniger :)

> Soo schlimm ist es ja aber glücklicherweise nicht.
> Ich wüsste jetzt kein vergleichbares Beispiel in Perl.
> Split / / vs. ' ' ist m.E. keins.

Wenn du split nicht in die gleiche Kategorie einordnest wie defined,
verstehe ich wohl einfach nicht, was dich jetzt genau stoert.


p

--
bellum omnium pater.

Re: Existtenztest auf Coderef

Frank Seitz:

> Die Referenz zeigt zwar nicht so sehr in den Wald wie
> ein Pointer in C in den Wald zeigen kann, aber immerhin führt
> ihre Nutzung (Aufruf) zu einem Programmabbruch, was im
> Endeffekt auf dasselbe hinausläuft, nur mit einer schöneren Meldung.

Naja, da Problem, Code zu schreiben, der zu einem Programmabbruch
führen kann, hat jeder irgendwann einmal, denke ich... ;-) da könnte man
jetzt zum Philosophieren beginnen... Es geht ja eben darum, den Code so
zu schreiben, dass das Programm nicht abbricht.

In deinem Beispiel legst du einen Referenz auf eine noch nicht existierende
Funktion an. Das ist weder verboten noch ungewöhnlich. Wesentlich ist,
dass du die Funktion definierst, bevor du sie aufrufst, was du aber auch
tun müsstest, wenn du keine Referenz verwendest. Diese Verantwortung
nimmt dir keiner ab. Mir ging es darum, zu zeigen, dass Referenzen in
Perl nie "in den Wald zeigen", sie zeigen allenfalls auf etwas, was für den
beabsichtigten Gebrauch (hier: Funktionsaufruf) (noch) nicht geeignet ist.
Wenn du die Funktion später zB. mit

*f = sub {..};

definierst, ändert sich an der Referenz nichts, aber trotzdem gibt's
keinen Abbruch mehr.

> Für deinen Fall würde sich eher "exists" anbieten:
>>
>> print exists(&$f) ? "exists" : "doesn't exist";

> Das dagegen funktioniert nicht!

Wieso nicht?

LG, Ferry

Re: Existtenztest auf Coderef

Ferry Bolhar schrieb:
> Frank Seitz:
>
>

>
>>Für deinen Fall würde sich eher "exists" anbieten:
>>
>>>print exists(&$f) ? "exists" : "doesn't exist";
>
>
>>Das dagegen funktioniert nicht!
>
>
> Wieso nicht?

Weil exists(&$f) auch dann true liefert, wenn die Funktion 'bla' aus dem
ursprünglichen Beispiel nicht definiert ist und $f->() demzufolge zum
Programmabbruch führt.

OP war:

------------------------
#!/usr/bin/perl -w

use strict;

my $f = \&{'bla'};
$f->();
------------------------


--

perl -e "print scalar reverse q/ed.enilno@ergn.l.hc/"

Re: Existtenztest auf Coderef

Ferry Bolhar wrote:
> Frank Seitz:
>>
>>Die Referenz zeigt zwar nicht so sehr in den Wald wie
>>ein Pointer in C in den Wald zeigen kann, aber immerhin führt
>>ihre Nutzung (Aufruf) zu einem Programmabbruch, was im
>>Endeffekt auf dasselbe hinausläuft, nur mit einer schöneren Meldung.
>
> Naja, da Problem, Code zu schreiben, der zu einem Programmabbruch
> führen kann, hat jeder irgendwann einmal, denke ich... ;-) da könnte man
> jetzt zum Philosophieren beginnen... Es geht ja eben darum, den Code so
> zu schreiben, dass das Programm nicht abbricht.

Richtig, genau deswegen benötige ich den Test, der mir
sagt, ob eine Code Referenz in den Wald zeigt (ich bleibe mal
bei der Formulierung).

> In deinem Beispiel legst du einen Referenz auf eine noch nicht existierende
> Funktion an. Das ist weder verboten noch ungewöhnlich. Wesentlich ist,
> dass du die Funktion definierst, bevor du sie aufrufst, was du aber auch
> tun müsstest, wenn du keine Referenz verwendest.

In meinem Fall geht es darum, die Nicht-Definiertheit einer
Funktion zu erkennen, die dynamisch hätte geladen werden sollen,
um diesen Fehler behandeln zu können.

> Diese Verantwortung
> nimmt dir keiner ab. Mir ging es darum, zu zeigen, dass Referenzen in
> Perl nie "in den Wald zeigen", sie zeigen allenfalls auf etwas, was für den
> beabsichtigten Gebrauch (hier: Funktionsaufruf) (noch) nicht geeignet ist.
> Wenn du die Funktion später zB. mit
>
> *f = sub {..};
>
> definierst, ändert sich an der Referenz nichts, aber trotzdem gibt's
> keinen Abbruch mehr.

Weiß ich doch alles.

>>Für deinen Fall würde sich eher "exists" anbieten:
>>
>>>print exists(&$f) ? "exists" : "doesn't exist";
>
>>Das dagegen funktioniert nicht!
>
> Wieso nicht?

-----------------------------------------------
#!/usr/local/bin/perl -w

use strict;

my $f = \&{'bla'};
die "Undefinierte Subroutine\n" if !exists &$f;
$f->();

__END__
Undefined subroutine &main::bla called at /tmp/test7.pl line 7.
-----------------------------------------------

Grüße
Frank
--
Dipl.-Inform. Frank Seitz; http://www.fseitz.de/
Anwendungen für Ihr Internet und Intranet
Tel: 04103/180301; Fax: -02; Industriestr. 31, 22880 Wedel

Re: Existtenztest auf Coderef

Christian Lackas:

> das in beiden Fällen »&f« verwendet wird, wenn es vor 'defined' benutzt
> wird aber etwas anderes zurückliefert als ohne. Das 'defined' ändert
> also die Bedeutung von '&f', die Funktion 'f' wird hier ja schlicht gar
> nicht aufgerufen.

Ich kenne die Bedeutung von '&f' als Funktionsaufruf, halte aber die Syntax
für unglücklich gewählt. Ich gebe gerne zu, dass ich als C-Programmierer
hier vielleicht vorbelastet bin, aber für mich ist und bleibt ein Funktions-
aufruf mit Klammerung verbunden. Ein

f();

oder wie in Franks Beispiel:

$f->();

ist wesentlich aussagefähiger als ein '&f' oder '&$f'. Ich würde das '&'
wirklich nur verwenden, wenn ich die Funktion "als Wert" ansich
ansprechen möchte, eben wie mit "defined" oder mit dem Referenz-
Operator ($funcref = \&func). Dann wäre auch klar, dass "&f" für sich
keine Funktion aufruft.. Das Problem mit @_ ließe sich sicher auch
auf eine andere Art (zB. spezielle Typing) lösen.

> Ich finde das persönlich aber völlig akzeptabel, da die '&'-Notation eh
> Perl4-Style ist und man sie aus diesem und einigen anderen Gründen nur
> verwenden sollte, wenn man genau weiss was man macht. Wenn man es
> trotdem ohne Nachzudenken benutzt, dann darf man sich auch nicht
> wundern, wenn @_ plötzlich unvorhergesehene Parameter enthät.

ACK.

LG, Ferry

--
Ing. Ferry Bolhar
Municipality of Vienna, Department 14
A-1010 Vienna / AUSTRIA
E-mail: bol@adv.magwien.gv.at

Re: Existtenztest auf Coderef

Frank Seitz:

> use strict;
>
> my $f = \&{'bla'};
> die "Undefinierte Subroutine\n" if !exists &$f;
> $f->();

Sorry, ich hatte dein Original-Posting vergessen und
es nicht mit einer Referenz probiert - wird die Funktion
direkt angesprochen, funktioniert es mit "exists" auch.

Hier wird geprüft, ob es den Codewert der Referenz
gibt (dh., das \&{'bla'}), und das ist ja der Fall. Es wird
nicht geprüft, ob der Codewert auch definiert ist (dh.,
einen tatsächlichen Wert = Funktionsbody) hat.

Wieder was gelernt!

LG, Ferry

--
Ing. Ferry Bolhar
Municipality of Vienna, Department 14
A-1010 Vienna / AUSTRIA
E-mail: bol@adv.magwien.gv.at