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

Re: How A Function Becomes Higher Order

by jdporter (Canon)
on Sep 16, 2005 at 18:10 UTC ( #492708=note: print w/ replies, xml ) Need Help??


in reply to How A Function Becomes Higher Order

Since closures are just another way of implementing encapsulation and re-use, I think it would behoove the programmer to choose the most appropriate elements of the program to refactor using this technique. In the case of your example, I think a better choice would be to "higher-order"ify the file accessing bits, since that's the most general-purpose part, and is likely to have the greater pay-off in terms of re-use. That's not to say that a max() function couldn't as well, but it seems to me to be the more application-specific algorithmic part.

sub with_file_do { my( $filename, $each_line_cb ) = @_; my $fh = new IO::File "< $filename" or die "read $filename - $!"; chomp, $each_line_cb->($_) while <$fh>; } my $max; with_file_do( $scores_file, sub { my( $score ) = @_; !defined $max || $max < $score and $max = $score; } ); print "max=$max\n";
Btw - I don't get the argument that named parameters aid extensibility. I frankly don't see any extensibility in this mechanism. Can you show how it would be done?


Comment on Re: How A Function Becomes Higher Order
Select or Download Code
Re^2: How A Function Becomes Higher Order
by Limbic~Region (Chancellor) on Sep 16, 2005 at 18:22 UTC
    jdporter,
    I agree that good judgement needs to be employed when deciding how to use this technique to solve a problem or if to use it at all. Perl does a great job of providing us many tools so that we can choose the right tool for the job. This basic tutorial was intended to introduce the concept and illustrate a basic example of the steps taken to transform a basic function into a Higher Order one.

    With regards to extensibility and named parameters, the advantage is clear when you consider optional parameters using the positional approach. Imagine your function starts out accepting 3 parameters. You then add an optional parameter which you stick on the end. Now if you want to add a 5th parameter you need to change the ordering of the parameters which will break backwards compatability. The issue gets even more complicated if you have more than one optional parameter.

    If this doesn't make my position clear, let me know and I will provide a concrete example using Tie::SortHash and Tie::Hash::Sorted.

    Cheers - L~R

      O.k., you're talking about extending the one function in situ, not the kind of extension that subclassing or aggregation gives.

      And that's essentially my complaint about this technique: it's nearly impossible to build large, extensible frameworks with. In my experience, functional programming works great at small levels of granularity; for anything larger, OO is far more useful. (Of course, the FP purists will disagree, and I'm not saying they're wrong.)

        In my experience, functional programming works great at small levels of granularity; for anything larger, OO is far more useful. (Of course, the FP purists will disagree, and I'm not saying they're wrong.)
        Indeed there are languages that support both paradigms. Most notably in this context, Perl itself. However to support is one thing and to enforce is another one; I'm curious about Objective Caml. Whatever the language, I wonder if there's any project that uses extensively both OO and FP techniques...
        And that's essentially my complaint about this technique: it's nearly impossible to build large, extensible frameworks with. In my experience, functional programming works great at small levels of granularity; for anything larger, OO is far more useful. (Of course, the FP purists will disagree, and I'm not saying they're wrong.)

        I certainly wouldn't describe myself as an FP purist, and I spend most of my time with OO languages these days, but I've found both FP and OO equally useful "in the large". Different techniques certainly, but both equally useful.

Re^2: How A Function Becomes Higher Order
by Anonymous Monk on Sep 16, 2005 at 19:56 UTC
    We're getting warmer. What we'd really like to do is reuse the abstractions and functions we've already got available. So you tie a file to an array, and use the standard collection traversal functions (map, grep, foreach, reduce, etc.) to do the dirty work. And be sure to make it lazy (demand driven) just like our familiar unix command line utilities. (see Chapter 9, pg. 142 of Advanced Perl Programming (the Panther)).

Log In?
Username:
Password:

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

How do I use this? | Other CB clients
Other Users?
Others taking refuge in the Monastery: (14)
As of 2014-07-22 21:15 GMT
Sections?
Information?
Find Nodes?
Leftovers?
    Voting Booth?

    My favorite superfluous repetitious redundant duplicative phrase is:









    Results (128 votes), past polls