Beefy Boxes and Bandwidth Generously Provided by pair Networks
Clear questions and runnable code
get the best and fastest answer
 
PerlMonks  

(tye)Re: When to use Prototypes?

by tye (Cardinal)
on Nov 09, 2001 at 21:17 UTC ( #124413=note: print w/ replies, xml ) Need Help??


in reply to When to use Prototypes?

Looking at the post in question, I'll guess that John is using prototypes to validate the number of arguments passed into each sub at compile time. I can certainly understand the desire to do that. I've even done that in the past. But I found that the misfeatures of Perl 5 prototypes outweighed this desirable effect (see the reference article for the full story on those misfeatures).

Now I only use prototypes for making compile-time constants and to emulate map's and grep's ability to take bare blocks as code references (and this latter use is quite rare and really only gives a very minor benefit of not having to see "sub" in front of each block).

Making compile-time constants is really the only use of prototypes that I can recommend.

BTW, I check the arguments passed into subroutines rather thoroughly, inside the subroutine, at run time. And I prefer to have test suites that validate the code paths so that this validation is effective before going into production, even though the checking isn't done at compile time. Since Perl uses a lot of late binding, checking subroutine arguments at compile time often just isn't possible.

        - tye (but my friends call me "Tye")


Comment on (tye)Re: When to use Prototypes?
Re: (tye)Re: When to use Prototypes?
by demerphq (Chancellor) on Nov 09, 2001 at 22:53 UTC
    Now I only use prototypes for making compile-time constants and to emulate map's and grep's ability to take bare blocks as code references (and this latter use is quite rare and really only gives a very minor benefit of not having to see "sub" in front of each block).

    Yeah the bare block trick was what I meant by 'unusual situations' :-) A quick question (which I could answer myself after a bit of testing, but it seems like a point that should be shared) doesn't it also coerce a statement into a block as well?

    My second question is how do prototypes help you with compile time constants? I assume you are talking about something like

    sub LOW_PRE_PI {3.141}
    and I dont see where prototypes come into play. Am I missing something?

    Yves / DeMerphq
    --
    Have you registered your Name Space?

      When you use an empty prototype (no args) for constants, the parser then knows not to interpret anything that follows as arguments for to that sub:

      sub LOW_PRE_PI {3.141} sub HI_POST_PI () {3.142} my @n_proto = (1, LOW_PRE_PI + 5, 11, 15); my @y_proto = (1, HI_POST_PI + 5, 11, 15); print "@n_proto\n@y_proto"; __END__ Output: 1 3.141 1 8.142 11 15

      In the first case, everything following the unprototyped version is taken as an argument list for the subroutine.

        Yes, that is one difference, but I find code that makes use of that difference to be a bit of a problem. I'd probably write HI_POST_PI()+5 if I noticed.

        The difference that I'm talking about is that subroutines with a () prototype that also do nothing but return a value become compile-time constants. Perl can replace instances of calls to these with the constant returned at compile time, allowing lots of interesting tricks:

        > Perl -MO=Deparse -w use strict; sub DEBUG() { 0 } sub SymRef() { "My::Package::hash" } sub PI() { 3.141592 } if( DEBUG ) { warn "Okay, we are debugging...\n"; do_lots_of_debugging_stuff(); } $My::Package::hash{key}= "value"; print SymRef->{key},$/; print PI()+5,$/; __END__ sub DEBUG () { 0; } sub SymRef () { 'My::Package::hash'; } sub PI () { 3.141592; } '???'; $My::Package::hash{'key'} = 'value'; print $My::Package::hash{'key'}, $/; print 8.141592, $/; - syntax OK
        Without the () prototypes we'd get:
        sub DEBUG { 0; } sub SymRef { 'My::Package::hash'; } sub PI { 3.141592; } if (DEBUG ) { warn "Okay, we are debugging...\n"; do_lots_of_debugging_stuff ; } $My::Package::hash{'key'} = 'value'; print SymRef()->{'key'}, $/; print PI() + 5, $/; - syntax OK
        and, if we ran the code, we'd get:
        Can't use string ("My::Package::hash") as a HASH ref while "strict refs" in use

                - tye (but my friends call me "Tye")
      Yesterday lestrrat showed how use constant $DEBUG works its magic Although he didn't specifically point out the bare prototype, it is there in the Deparsed output...

      -Blake

Re: (tye)Re: When to use Prototypes?
by astaines (Curate) on Nov 12, 2001 at 04:57 UTC

    tye says "And I prefer to have test suites that validate the code paths so that this validation is effective before going into production, even though the checking isn't done at compile time."

    This sounds like a good idea, but I'm not sure that I entirely understand it. Do you mean that you systematically exercise all of the possible paths through your program? What's a good way to actually do this in Perl?

    More generally most of the modules that I've looked at have very specific tests, running a function or two from the module on defined data. This is also a good idea, and it's what I've (slavishly) copied in my own work. Could some experienced person point me ot resources on more albaorate testing of Perl software? I'm personally especially interested in database driven web sites with CGI.pm etc.

    -- Anthony Staines

Log In?
Username:
Password:

What's my password?
Create A New User
Node Status?
node history
Node Type: note [id://124413]
help
Chatterbox?
and the web crawler heard nothing...

How do I use this? | Other CB clients
Other Users?
Others perusing the Monastery: (12)
As of 2014-10-24 16:59 GMT
Sections?
Information?
Find Nodes?
Leftovers?
    Voting Booth?

    For retirement, I am banking on:










    Results (133 votes), past polls