G'day harangzsolt33,

"I would like to point out a distinction."

You have failed to do that. The 108 lines of code that you've posted contain no references to functions, subroutines, or any other code.

Calling a variable $CODE_REF does not make it a coderef. $CODE_REF is not any kind of reference; it's just a string:

$ perl -MO=Deparse -e 'my $CODE_REF = \"if (\$c == 64) { \$MODE = prin
+t \"\\n\"; }" . " else { print chr(\$MODE = \$MODE & 1 ? 32 : 35) x \
+$c; } ";'
my $CODE_REF = 'SCALAR(0xa00038be0) else { print chr($MODE = $MODE & 1
+ ? 32 : 35) x $c; } ';
-e syntax OK
[download]

You can explicitly check it yourself:

$ perl -e 'my $CODE_REF = \"if (\$c == 64) { \$MODE = print \"\\n\"; }
+" . " else { print chr(\$MODE = \$MODE & 1 ? 32 : 35) x \$c; } "; my 
+$ref = ref $code_ref; print $ref ? $ref : "not a ref";'
not a ref
[download]

Or let Perl do it for you:

$ perl -Mstrict -e 'my $CODE_REF = \"if (\$c == 64) { \$MODE = print \
+"\\n\"; }" . " else { print chr(\$MODE = \$MODE & 1 ? 32 : 35) x \$c;
+ } "; $CODE_REF->();'
Can't use string ("SCALAR(0xa00038c70) else { print"...) as a subrouti
+ne ref while "strict refs" in use at -e line 1.
[download]

"Is there any other way to do it?"

You can modify a caller's variables by passing references to those variables. Here's a very simple example:

#!/usr/bin/env perl

use strict;
use warnings;

my ($x, $y) = qw{X Y};

print "BEFORE:\n";
print "\$x[$x] \$y[$y]\n";
mod_callers_vars(\$x, \$y);
print "AFTER:\n";
print "\$x[$x] \$y[$y]\n";

sub mod_callers_vars {
    my ($x_ref, $y_ref) = @_;
    $$x_ref = 'A';
    $$y_ref = 'B';
    return;
}
[download]

Output:

BEFORE:
$x[X] $y[Y]
AFTER:
$x[A] $y[B]
[download]

I see LanX has shown you how to use closures (which could be appropriate for more complex scenarios).

In "Re^4: Aren't there code refs as well as function refs?", you wrote:

"... you decide to call each function with 30 or so arguments."

That would be a very poor decision. Instead, use a single hashref argument.

> You can modify a caller's variables by passing references to those variables.

here a 2 variants with aliases instead of passing references

# https://perlmonks.org/?node_id=11150731
use strict;
use warnings;

my ($x, $y) = qw{X Y};

print "BEFORE:\n";
print "\$x[$x] \$y[$y]\n";

mod_callers_vars1($x, $y);
print "AFTER1:\n";
print "\$x[$x] \$y[$y]\n";

mod_callers_vars2($x, $y);
print "AFTER2:\n";
print "\$x[$x] \$y[$y]\n";


sub mod_callers_vars1 {
    @_[0,1] = ('A','B');
    return;
}

sub mod_callers_vars2 {
    my ($x_ref, $y_ref) = \(@_);
    $$x_ref = 'C';
    $$y_ref = 'D';
    return;
}
[download]

--->

BEFORE:
$x[X] $y[Y]
AFTER1:
$x[A] $y[B]
AFTER2:
$x[C] $y[D]
[download]

Cheers Rolf
_{(addicted to the 𐍀𐌴𐍂𐌻 Programming Language :)
Wikisyntax for the Monastery}

Could you please elaborate?

Okay, I wrote a function called DrawPattern() which reads a string and calls PrintPattern() for each character read. This PrintPattern() function is responsible for printing the characters. The way it works is this: For each even numbered character, it prints N number of spaces, and for each odd numbered characters, it prints N number of '#' signs. So, this function has to know whether we're on even or odd numbered character. And it not only has to know that but it also flips it each time. So, it modifies the state. The function DrawPattern() has a state, which is stored in the $MODE variable. I show three different solutions to accomplish this.

So, the main issue is how do we modify the state? Imagine that we have a very large sub that does a lot of things and spans hundreds of lines of code. To make that easier to read, you could try to break it up into individual functions. The problem occurs when this large function also has a lot of variables which all need to be seen by the individual sub functions. So, now, in order to make these variables available to each function, you decide to call each function with 30 or so arguments. Your code will get really messy, and you'll start wondering if it had been a better idea to just leave the giant sub as one piece of code.

A third solution would be to have code refs which are kind of like inline code in C language. You make a declaration at the top of the program #define WHATEVER is going to be replaced with "if (x > 63) { ... }" and from that point on, every time you mention "WHATEVER," it will be replaced with "if (x > 63) { ... }" before compilation begins. It's a very neat feature in C language, but as far as I know, Perl doesn't have that feature. What Perl has is called the eval() function, so we could do something like that.

We could create a function called WHATEVER() that doesn't do anything but simply returns a block of text. Then you do eval(WHATEVER()); and it gets executed. The trick here is that even though you are writing WHATEVER()'s code, you can make references within WHATEVER() to the caller's private variables, and when you execute it using eval(), it will run like it's part of the parent function. So, even though you have sliced the code up into smaller functions, you can still reference the parent's variables. You don't have to pass every variable as an argument.

(The problem is when you put this into a loop, there is a considerable loss of performance when you run eval() over and over again. Using a function call is slower than having one giant sub, but using a function call PLUS eval() together makes things really slow. So, it should not be used inside a loop.)

sub DrawPattern3
{
  my ($PATTERN, $LENGTH, $MODE, $c) = GetPattern($_[0]);

  for (my $i = 0; $i < $LENGTH; $i++)
  {
    $c = ord(substr($PATTERN, $i, 1));
    eval(WHATEVER());
  }
}

sub WHATEVER
{
  return "if (\$c == 64) { \$MODE = print \"\\n\"; next; }"
      . " print chr(\$MODE = \$MODE & 1 ? 32 : 35) x \$c; ";
}
[download]

Wow, I think you are reinventing wheels but at high rotation. :)

> Imagine that we have a very large sub that does a lot of things and spans hundreds of lines of code. To make that easier to read, you could try to break it up into individual functions. The problem occurs when this large function also has a lot of variables which all need to be seen by the individual sub functions.

Are you aware of the concept of closure variables° in functional programming or instance-variables in OOP?

If yes did you consider using them here?

> A third solution would be to have code refs which are kind of like inline code in C language

These are not code-refs but preprocessor macros.

Actually Perl supports them, but I never saw them used. It might also depend on the existence of an installed C preprocssor.

Another better portable approach are source-filters.

But as I said above, I think there are already better solutions for that. Preprocessor macros are dangerous.

Anyway I'm still unsure in which way all of this was related to the OPs question.

Cheers Rolf
_{(addicted to the 𐍀𐌴𐍂𐌻 Programming Language :)
Wikisyntax for the Monastery}

update

°) example

sub huge_function {
    my $many, $variables, ...;

    # do something

    # do something else
}
[download]

---->

{
    my $many, $variables, ...;   # accessible inside all closed over s
+ubs here

    sub previously_huge_function {
       # set $many ...

       do_something();

       do_something_else();
      
    }

    sub do_something {
        my $internal_var;
        # access $many...
    }

    sub do_something_else {
        my $internal_var;
        # access $many...
    }

}
[download]

This will work:

Can't use string ("SCALAR(0x26afcc8) else { print c"...) as a SCALAR r
+ef while "strict refs" in use at garbage.pl line 100.
[download]