Slash Boxes
NOTE: use Perl; is on undef hiatus. You can read content, but you can't post it. More info will be forthcoming forthcomingly.

All the Perl that's Practical to Extract and Report

use Perl Log In

Log In

[ Create a new account ]

Aristotle (5147)


Blah blah blah blah blah []

Journal of Aristotle (5147)

Saturday November 08, 2008
11:49 AM

A simple `unfold` in Perl

[ #37831 ]

For many years, a very simple issue about writing an unfold in Perl 5 has stymied me.

(An unfold is the opposite of fold, of course. The latter is better known to Perl programmers as reduce from List::Util, which is a function that takes a block and a list and returns a single value by repeatedly applying the block to successive values. An unfold does the opposite: it takes a block and a single value and then repeatedly applies the block to the value, accumulating the return values to eventually return them as a list.)

A good unfold as I want it will allow the same thing as map does: for any iteration to return any number of elements, including zero. Also, the elements returned from an iteration must be passed out of the block as its return value for that iteration – otherwise you might as well write a conventional loop instead.

But then you have a problem: how do you know when the block is finished generating output? There is no possible return value you could use for this. The Python implementations of this function that I’ve seen invariably expect an exception to be thrown to signal the end of the iteration, which struck me as profoundly un-Perlish. But how else do you signal the termination condition out of band?

I could think of no sensible solution given the combination of constraints that I adopted. Until an hour ago, that is, when a flash of inspiration struck me.

I’ll let the code speak for itself.

sub induce (&$) {
    my ( $c, $v ) = @_;
    my @r;
    for ( $v ) { push @r, $c->() while defined }

In this version, the initial scalar value is made available to the block in $_ (somewhat cleverly done via for, which is necessary because local $_ has lots of subtle pitfals), and the block is called repeatedly as long as $_ is defined. The block therefore signals the detection of its exit condition by undefining $_.

It’s that simple. It’s so simple I cannot believe it took me so many years to think of it, but there it is.

Here is a silly example:

my @reversed = induce { @$_ ? pop @$_ : undef $_ } [ 1 .. 10 ];

Of course, the eagle-eyed will immediately notice a problem: this produces 11 return values, the last one being the undef that got returned from undef $_. The fact that induce will collect the value of the final iteration rather than throw it away was a conscious design decision: there are two cases for the return value of the final iteration, either it is useful or not. What happens if it it’s not useful, but would be collected? Then you have to suppress it, which is easy. What happens if it’s useful, but would be thrown away? Then you have to arrange for the block to remember state so it can return the useful value first and then signal the termination condition on its next invocation. Since it is so much easier to suppress useless values that would be kept than to retain useful values that would be dropped, I chose to have induce keep the final iteration’s value.

There are various ways to arrange the suppression in the above example. One of them is to check more eagerly for whether another iteration will be necessary:

my @reversed = induce { my @l = @$_ ? pop @$_ : (); @$_ or undef $_; @l } [ 1 .. 10 ];

That is clearly extremely awkward. A simpler (and insignificantly less efficient) approach is to suppress the value returned by the undef function:

my @reversed = induce { @$_ ? pop @$_ : ( undef $_, return ) } [ 1 .. 10 ];

That’s much better, but still not pretty. In particular, that return can be awkward to place due to precedence rules. In the above example it requires those annoying parens. (Try it: the code compiles but breaks without them.) Instead, we’ll take a page from Javascript and write another function:

sub void {}

No, seriously. The point of this function is, well, to take any arguments you pass it, throw them away, do nothing, and return nothing – most importantly, to return an empty list in list context.

I admit that writing this, err, function greatly amused me. But the end result is quite satisfying:

my @reversed = induce { @$_ ? pop @$_ : void undef $_ } [ 1 .. 10 ];

So these two functions, induce (named like this instead of unfold, of course, to contrast with List::Util’s reduce) and void, will probably start appearing in my small scripts from now on.

The Fine Print: The following comments are owned by whoever posted them. We are not responsible for them in any way.
More | Login | Reply
Loading... please wait.
  • couldn't you write…

    my @reversed = induce { @$_ ? pop @$_ : end_of_fold } [ 1 .. 10 ];

    …and have end_of_fold undef $_?

    If you used a different localised variable, you might also be able to unfold undef values. But I don't really know if that is wanted.


    Ordinary morality is for ordinary people. -- Aleister Crowley
    • That makes it seem like the end_of_fold function is somehow special. I’d prefer people who use this to understand exactly how it works, and avoiding low-gain abstractions helps.

  • Why not return []'s which get flattened into the output until undef is returned?

        my @rev = induce {@$_ ? pop @$_ : undef} [1..10];

    But maybe I'm missing something as to why the prototype is &$ instead of &@, or am just wanting a better example? I would think that unfold might be more like:

        my @flat = map({map({$_} @$_)} [1..10],[12..20]);

    or thereabouts - and the 'reverse' example does not clarify that for me.

    • Why not return []’s which get flattened into the output until undef is returned?

      Because then there has to be an escape mechanism for the block to be able to return an actual [] that should be preserved in the output, and the block has to make sure to use it when appropriate.

      But maybe I’m missing something as to why the prototype is &$ instead of &@

      Because unfold (“induce”) takes a single value and inflates it to a list, as opposed to fold (reduce) which takes a list and def

      • Why not return []’s which get flattened into the output until undef is returned?

        Because then there has to be an escape mechanism for the block to be able to return an actual [] that should be preserved in the output, and the block has to make sure to use it when appropriate.

        No, you would not reach inside the returned ref - only flatten it at the first level. It is either [] or undef, so [[]] would be a list of one reference.

            my @power = induce {
                my $r = $_ % 12
                $_ /= 12;
                return $r ? [$r] : undef;
            } 4711;

            my @chunk = induce {
              (length) ? [substr $_, 0, 3, ''] : undef
            } "foobarbaz";

        The return $condition ? [@stuff] : unde

  • I played a bit with the concept, and found an issue I can't resolve, possibly you can help me here. The problem concerns whether $_ is an alias or a copy to the parameter passed. If it is a copy then you can't modify it unless it is a reference. If it is an alias you can't modify it if it is read-only. You may ask why should it be modified at all, and here comes the classic unfoldr:

    unfoldr { $_ ? ($_, $_ - 1) : () } 10;


    which allows to pass arbitrary values to the callback .

    • Read my post; I addressed that concern. To reiterate: because the empty list is a valid return value. I want to be able to make compute state transitions on the input value without them having to contribute to the resulting list.

      It’s not hard to convert a read-only value to modifiable copy.

      if I want to send values other than the original parameter to myself (e.g. callback), then I can’t.

      You can. You just have to capture them with a closure. Admittedly that’s cumbersome.

      So yeah, it’s

      • Oh well, I could say the same, read my post; I addressed that concern too :) unfoldr actually allows to return empty lists. Here's a hacked quote from haskell description:

        The unfoldr function is a `dual' to foldr: while foldr reduces a list to a summary value, unfoldr builds a list from a seed value. The function takes the element and returns empty list if it is done producing the list or returns (@a,$b), in which case, @a is a appended to the list and $b is used as the next element in a recursive call.

        • But then you need to drag it along through all of your return values. That is cumbersome.

          Using $_ for the purpose is more idiomatic. The problem is in reusing $_ to signal the last iteration – that prevents you from unfolding undef, should you want to, and it bloats the code by your having to be careful not to return that undef when you meant to stop iterating.

          However I can’t think of any good way to signal termination out of band.

    • Btw, no, your point about alias vs copy is mistaken. The induce function above takes a copy of the value and then aliases $_ to that copy, so you are guaranteed to be able to modify the value, although if you want to preserve its last value past the unfolding, you want to arrange for that yourself.