package A;
    use B;
    BEGIN { ... }
    END   { ... }
[download]

Then the BEGIN blocks of B are run before the one's in A (because the compiler sees them earlier), while the END blocks of A are run after any END blocks of B (because the compiler sees the one in A after the one's in B).

true.

But that's still the BEGIN-in-FIFO/END-in-LIFO that that was being discussed. My point was more to the fact that since this...

package A;
BEGIN { ... $a ... } // A's 0th BEGIN
use B $a;
END   { ... }        // A's 0th END
[download]

...is basically this...

package A;
BEGIN { ... }                      // A's 0th BEGIN
BEGIN { require B; import B $a }   // A's 1st BEGIN
END   { ... }                      // A's 0th END
[download]

...you really want to make sure that A's 0th BEGIN block, happens before it's 1st BEGIN block (which so happens to get executed before B's 0th BEGIN block -- if it has one.)

I don't think the OP was wondering about the FIFO-ness of BEGIN, but more about the LIFO-ness of END and CHECK.

Abigail

With apologies, because I'm sure my question has already been answered but I'm too dense to recognize that fact... :)

If module A "uses" module B, then you want module A's BEGIN block to run before modules B's BEGIN block. When cleanup happens, you want module B's END block to run before module A's END block.

Given these modules

# this is A.pm
package A;

BEGIN { print "Haven't used B yet\n" }
use B;
BEGIN { print "Just used B\n" }


END { print "Exiting A\n" }

1;



# this is B.pm
package B ;

BEGIN {
  # open a file or exit(1) with a message to STDERR
  open B_FH, 'somefile' or exit warn "somefile: $!\n" ;
}

END {
  close B_FH ;
  print "Exiting B\n" ;
}

1;
[download]

If I read your post correctly, you're saying that I want module B's END block to run before module A's END block. If this is what I wanted, I think I'd be disappointed: A use's B, which means that 'use B' in A causes us to fully parse B before finishing parsing A. Therefore, B's END block is loaded before A's END block. This makes A's END block Last In, thereby First Out.

The truth is, I actually don't care in which order ENDs and CHECKs get called. I just want to know why BEGIN/INIT are FIFO and END/CHECK are LIFO.