include file "inline"

[rsiedl]

Hey Monks,

Can anyone tell me if its possble to include a file "inline" in a perl script?
i.e.

#!/usr/bin/perl

use SOME::Module;

my $blah = new SOME::Module;
$blah->start;
use 'guts.pl';
$blah->end;

exit;

and guts.pl might look like:

#!/usr/bin/perl

my %data = ( lots of data );
foreach (keys %data) {
  $main::blah->calc($_);
}

exit;

I know this code is useless and wont work, it's just to help explain my question :)

Cheers,
Reagen

[davorg]

You're probably looking for something like do. But you'd almost be certainly be better off creating a "real" module.

[jkva]

You can also make use of require. This does not make the methods / variables in there "inline", though. If you truly want to import methods / variables into your script go with davorg's advice.

[NiJo]

Maybe you are looking for 'here doc's':

[zentara]

Inline::Files

[Limbic~Region]

zentara,
The way I interpret the question, Inline::Files won't help. I believe rsiedl is asking for a way to inline code. Given the example provided, I think davorg is more on tract.

[broquaint]

If you can get past the caveats of source filtering then use Filter::Include to truly inline your code.

[ambrus]

See this tutorial: Including files.

Update: see also How to include files in perl? and File inclusion.

[kutsu]

Since everyone else has meantioned how to inline perl code, and seeing the use SOME::Module; and OOish construct, I'm assuming you might be asking how to create an OO module. If that's the case your half way there:

The calling perl file (ie. foo.pl)

#!/usr/bin/perl
use warnings;
use strict;

@data = qw(gotta have guts to code perl);

use Guts;
my $Gs = Guts->new;
$Gs->gutsy(@data);

The module (ie. Guts.pm):

pakage Guts;

sub new 
{
  my $class = shift;
  my $self = {};

  $self = bless($self, $class);
  return $self;
}

sub gutsy
{
  $self = shift;
  print join(" ", @_);
}

1;

The key points being look at perltoot, bless, and perlobj

[radiantmatrix]

do works, to a point, as does require. However, neither will let inline code see the surrounding scope. The only way to do this is with a fairly risky eval:

use File::Slurp;   #!important!

my $blah = new SOME::Module;
$blah->start;

eval read_file('guts.pl');

$blah->end;

This is not recommended, partly because it's slow. Eval can be risky, too, so read up on it before choosing something.

It's easy to build modules, so I strongly recommend that as an alternative course of action.