#!/usr/bin/perl

print "Content-type: text/html\n\n";
print "here we go again...";

        if (eval "require LWP::UserAgent; use HTTP::Request::Common; 1
+;") {
                my $ua = LWP::UserAgent->new;
                my %post;
                my $content = $ua->request(POST "http://www.cnn.com", 
+[%post])->as_string;
                print $content;
        } else {
                print "didnt work";
        }
[download]

./networktest.pl
String found where operator expected at ./networktest.pl line 10, near
+ "POST "http://www.cnn.com""
        (Do you need to predeclare POST?)
syntax error at ./networktest.pl line 10, near "POST "http://www.cnn.c
+om""
Execution of ./networktest.pl aborted due to compilation errors.
[download]

You must use parens around the arguments of a function call when the call is compiled before the function being called has been loaded.

My solution doesn't suffer from that problem. It loads the function (i.e. the module) before the call to the function is compiled.

So either add parens around the arguments for POST (and suffer from the loss of prototypes on all imported functions), or use what I already posted.

print "Content-type: text/html\n\n";
print "here we go again...";

&a;

sub a {
        BEGIN {
                eval ("use fakemodule;");
                if ($@) {
                        print "error happened $@";
                } else {
                        print "error didnt happen, do some stuff";
                }
        }
}
[download]

Considered by ikegami: Dup of Re^2: Why am I getting "premature end of script header"?
Unconsidered by Arunbear: reaping blocked by keep (and edit) votes; (Keep: 5, Edit: 3, Reap: 18)

This would be sufficient:

BEGIN {
    if( eval "use fakemodule; 1;") {
        print STDERR "Loaded fakemodule";
    }
    else {
        print STDERR "Couldn't load fakemodule.";
    }
}
[download]

Don't put BEGIN blocks inside a subroutine, they won't do what you want.

Don't print in the BEGIN block, it will come before the Content-type header

Calling a subroutine with the '&a' syntax has the following effects, from perlsub:

• &NAME(LIST); # Circumvent prototypes.
  
• &NAME; # Makes current @_ visible to called subroutine.
In your code you used the &a; form, which would make the current @_ visible to the called subroutine. For example:

first(1,2,3);

sub first {
  &second;
}

sub second {
    print for @_;
}

# Output is 123
[download]

Although it isn't relevant for this particular case it is still good to be aware of the prototype circumvention behaviour. Here is an example:

use strict;
use warnings;
use Data::Dumper;

sub pro(\@) {
    print Dumper \@_;
}

my @list = (1,2,3);
pro(@list);
&pro(@list);
[download]

Output:

$VAR1 = [
          [
            1,
            2,
            3
          ]
        ];
$VAR1 = [
          1,
          2,
          3
        ];
[download]

thank you... so the takeaway message is that I should call subroutines via subroutine; and not &subroutine;? this must be a new thing? because the Perl book I have (admittedly the first edition o'reilly one) says that i should call subroutines with the ampersand...?