Beefy Boxes and Bandwidth Generously Provided by pair Networks
Think about Loose Coupling

Re^3: $_ functions vs argument-using functions

by LanX (Bishop)
on Sep 09, 2013 at 19:12 UTC ( #1053084=note: print w/replies, xml ) Need Help??

in reply to Re^2: $_ functions vs argument-using functions
in thread $_ functions vs argument-using functions

> (e.g. map prefers such functions)

thats a misunderstanding, because the normal (ok nowadays recommended) way to use map is with a block using the default var. So "map prefers blocks"!

From this point of view writing map { f($_) } 1..3 is the canonical approach!

But this means overhead, because map calls now two functions in a row (the block means an anonymous function).

To avoid this, some experts prefer using the EXPR syntax  map f, 1..3 which is magic (which means a parsing exception introduced for DWIM and syntactic sugar).

Because a bareword in Perl almost always means a function call², if you need the function reference of f you need to write \&f, but some builtins like map and grep magically (sic) accept expressions.

Since you are replacing the block with f you have to mimic the behaviour to use $_ - a localized global variable - in the function body.¹

Your problems understanding all of this derive from the fact that you are starting with the rare syntax exceptions.

Clearer now?

(BTW: I always wanted to write a cross-manual explaining Perl vs JS, to highlight the details in both languages, but somehow all people told me there is no need... )

Cheers Rolf

( addicted to the Perl Programming Language)

¹) The trick with the (_) prototype is rather new, it passes $_ into @_ if an argument is missing.

²) opposed to languages like JavaScript where a bare f is ALWAYS the reference of function f(a,b,c){ ... }


if you are interested in functional programming, try having a look into *Higher Order Perl* - you can download it for free.

Replies are listed 'Best First'.
Re^4: $_ functions vs argument-using functions
by tobyink (Abbot) on Sep 09, 2013 at 21:26 UTC

    "But this means overhead, because map calls now two functions in a row (the block means an anonymous function)."

    Actually the block used by map and grep is not an anonymous function; it's just a block like if and while take. It does have a little overhead because it creates a lexical scope (it can have my variables defined within it); however not as much overhead as an anonymous sub would - calling it doesn't require stack fiddling, localizing @_, etc.

    It's quite easy to confirm it's not an anonymous sub - check how caller and return behave inside a map or grep block, and compare them with what happens in an anonymous sub. return doesn't return from the map block; it returns from the outer sub.

    With non-built-in functions that at first glance seem similar to map and grep (for example, List::Util's first), the block is an anonymous sub, so there is more overhead calling it. But not necessarily as much as you might think; List::Util takes advantage of an interface Perl exposes to XS code called "multicall" allowing it to repeatedly call the same anonymous sub without stack fiddling for each call - it does the stack fiddling just once, and then for each call sets @_ and runs the body of the sub.

    use Moops; class Cow :rw { has name => (default => 'Ermintrude') }; say Cow->new->name
      Wow, thanks for the info!

      ( learned again something new in the universe of Perl's special cases... ;-)


      so from a performance point of view there is no reason to prefer map f, 1..3 over map { g($_) } 1..3!

      Cheers Rolf

      ( addicted to the Perl Programming Language)

        As I said, the block form does add a little overhead, because it creates a lexical scope. It's very minor though, so it's generally better to go with whatever you think is more readable.

        When you need to micro-optimize a tight loop that gets called millions or billions of times... that's when you start looking at removing unnecessary lexical scopes! The block forms of grep and map can be replaced with the expression forms; if/elsif/else chains can become ternary operator expressions; foreach blocks become statement modifiers; etc.

        use Moops; class Cow :rw { has name => (default => 'Ermintrude') }; say Cow->new->name

      Very interesting information, indeed. As I am sure many other monks before me and probably others after and in the future, I have tried a couple of years ago to rewrite in Perl a "my_map" and a "my_grep" functions (just for the sake of experimenting). And, if my memory serves me right, I ended up writing a simple anonymous function; then adding a code-ref prototype to my_map was all what was needed to mimic exactly the block syntax of map (getting rid of the sub keyword). So, I also considered the map block to be more or less equivalent to an anonymous function and I actually wrote today, just a few hours ago, in answer to another question of the original poster of this thread, that "the (map) block can be regarded as an anonymous function" (in this thread: map sub to list?). From the functional point of view that I was using, I think it is probably right to put it this way and that I probably don't need to change anything to my formulation, but it is quite interesting to know that from an implementation point of view, there is a significant difference which has an impact on performance. Anyway, thank you for the implementation details, this is very useful to know.

Re^4: $_ functions vs argument-using functions
by pldanutz (Acolyte) on Sep 09, 2013 at 19:23 UTC
    Yeah. These magic parsing exceptions are clearly not accessible to normal users, especially since the perldoc page doesn't seem to document it at all. How was I supposed to find out about this exception reading the docs?

    In any case, I cannot include a large amount of code in an anonymous block passed to map(). So I guess this sanctions the use of $_-using functions.

      It's documented, see perlglossary for "expression".

      The point is you can't reuse this coding style very often, so better avoid it.

      You can write sub func (&@) { } to use block syntax. like in func {shift()+1 } 1..10

      Or you can directly pass function references  f(\&g(\&h),1..10)

      or anonymous subs  f(sub {...},1..10)

      without using prototypes at all.

      But Perl won't allow you to rewrite anything like func EXPR, LIST acting like map does.

      And as I said have a look into HOP.

      Please understand that I won't go further into details of a theoretical discussion, I'd rather prefer to see a real use case from you such that we can recommend the Perl way to do it.

      Cheers Rolf

      ( addicted to the Perl Programming Language)

Log In?

What's my password?
Create A New User
Node Status?
node history
Node Type: note [id://1053084]
and all is quiet...

How do I use this? | Other CB clients
Other Users?
Others taking refuge in the Monastery: (5)
As of 2018-06-23 16:56 GMT
Find Nodes?
    Voting Booth?
    Should cpanminus be part of the standard Perl release?

    Results (125 votes). Check out past polls.