Nastiest Python list comprehension ever

I tried a bit in the REPL and couldn't replicate it completely, but I didn't try hard. It seems to only work because of the CPython internals, so it seems to be implementation-specific and undocumented.

Python still has (even in 3.2) os.system, which is the equivalent of the backticks from perl/shell. The subprocess module is preferred because you have more control and options than simply deferring to the C library's system() call.

shells were specifically made to operate with external programs (the Unix way) while Python is a more general programming language, so naturally it will be more verbose for this kind of task.

Of course the first syntax breaks when one of the arguments has a space or any other meta-character in it.

You picked an example where Python took a step backwards in readability. That's fair but surely not typical. I agree it was a loss since I'm a huge fan of language usability-- in Python 2.5 os.popen is really rather simple to read and use.

You can do that quite cleanly in Python:

import commands print commands.getoutput("your system call and args")

That is certainly ugly, but sadly it's the option I prefer nowadays. In perl I use 3 argument open with a pipe instead of backticks. Especially if any of your args come from a variable--suddenly you have to think of shell quoting in your perl code. Yuck.

Perl desperately needs a built-in backtick() function:

    my $x = backtick(qw(my-program -l -V), "--option=$something", @files);

Maybe in perl you'd call it ``() or something instead of backtick().

Any time you see a three arg for loop in perl golf, it's probably Doing It Wrong.

Add some spaces:

    sub sieve {
        sub p {
           $_[0] , @_>1 ? p(grep$_%$_[0],@_) : 1;
        }
        p(2..pop)
    }

And if you get rid of some terse syntax:

    sub p {
        my ($first, @rest) = @_;
        if (@rest > 1){
            return $first, p(grep { $_ % $first } @rest);
        }
        return 1;
    }

    sub sieve {
        my $arg = shift;
        return p(2..$arg)
    }

BTW, you can even have Perl do this automatically for you, by running:

    $ perl -MO=Deparse
    <paste in the code>
    sub p {
        $_[0], @_ > 1 ? p(grep(($_ % $_[0]), @_)) : 1;
    }
    sub sieve {
        p 2 .. pop @_;
    }

But honestly, the first program is not incomprehensible if you've ever programmed in Perl. Sure, it ain't literate programming, but it also isn't beyond understanding if you have three minutes to spend on it.

It's an amusement, not your payroll system, after all.

I am sure that this is Perl. Let me build it up as it executes.

First, pop returns the last element of an array. If no array is specified, @_ is used, which is the default array into which function arguments are passed. Therefore pop gets at the last argument. If this function is called with one argument, it gets at the first argument.

  sub sieve3 {
      pop
  }

Next .. is the range operator. It builds up a list from one number to another. In our case it will be building up a list of the possible numbers we will be searching for primes in.

  sub sieve3 {
      0..pop
  }

As I mentioned before, @_ is the default array. Let's assign that list there so that it is available in a convenient way. To get at element $n (in Perl, '$' basically means 'the') you would write $_[$n]. If you have an array @things, you can create a slice with @_[@stuff].

  sub sieve3 {
      @_=0..pop
  }

Next what grep does is run some piece of code for every element in a list and returns the values that were true. The list element is always aliased to $_. (Default things are named _, and as before, $ means the. So $_ is "the default thing.")

  sub sieve3 {
      grep{ ... test $_'s primality ... }@_=0..pop
  }

We started with an array @_. The algorithm is that we'll go through that list, every time we encounter a prime we drop all of the multiples from the list and have a true value so we encounter it. Every time we encounter something that has been struck out we see that it has been struck out, and that test is false.

We will be striking out elements by assigning 0 or undef to them, this test for whether we're less than 2 eliminates 0, 1, and all previously struck out non-primes.

  sub sieve3 {
      grep{ ... filter out multiples of $_ ... if$_[$_]>1}@_=0..pop
  }

We'll do the striking by assigning 0 to a list of multiples. This sets the first to 0 and the rest to undef.

  sub sieve3 {
      grep{@_[ ... multiples of $_ ... ]=0if$_[$_]>1}@_=0..pop
  }

We need a list of all of the numbers from $_ to the number of elements over $_. Luckily @_ used in a calculation tells us the number of elements it has.

  sub sieve3 {
      grep{@_[... turn into list of multiples... $_..@_/$_]=0if$_[$_]>1}@_=0..pop
  }

Unfortunately the code that we'll use to make the list of multiples will reuse the default variable $_, so we need to alias this $_ to a new variable, $a.

  sub sieve3 {
      grep{@_[ ... turn into list of multiples ... $_..@_/($a=$_)]=0if$_[$_]>1}@_=0..pop
  }

And now we introduce map. Map is like grep, except that it transforms elements in place. The transformation here is that we want $a * $_. Note that there are 2 loops here, one from the grep and one from the map. $a is the variable from the grep, and $_ from the map.

  sub sieve3 {
      grep{@_[map$a*$_,$_..@_/($a=$_)]=0if$_[$_]>1}@_=0..pop
  }

And now for the nastiest bit (you thought we were done??). Grep evaluates that slice in scalar context. In scalar context an array tells you the size of the array. The slice we're assigning to always has size at least 1 because we're assigning 0 to it, so whether or not the list of indexes is 0 we get a true value. (Don't worry if you didn't understand that, the upshot is that we're returning a true value when we see primes, so that grep will return them.)

And there is the entire Sieve of Eratosthenes. In surprisingly little Perl.