Defer in Perl

In Perl, we don’t have a direct equivalent to the defer keyword. However, we can achieve similar functionality using the END block or object-oriented programming techniques. For this example, we’ll use an object with a destructor to mimic the defer behavior.

Our program will create a file, write to it, and then close it when we’re done. Here’s how we could do that in Perl:

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

# Define a FileHandler class
package FileHandler;

sub new {
    my ($class, $filename) = @_;
    my $self = {
        fh => FileHandle->new("> $filename"),
    };
    bless $self, $class;
    print "creating\n";
    return $self;
}

sub write {
    my ($self, $data) = @_;
    print "writing\n";
    $self->{fh}->print($data);
}

sub DESTROY {
    my $self = shift;
    print "closing\n";
    $self->{fh}->close or die "Could not close file: $!";
}

package main;

# Main function
sub main {
    my $f = FileHandler->new("/tmp/defer.txt");
    $f->write("data\n");
    # The file will be automatically closed when $f goes out of scope
}

main();

In this Perl version:

1. We define a FileHandler class that handles file operations.
2. The constructor (new) creates the file and prints “creating”.
3. The write method writes to the file and prints “writing”.
4. The destructor (DESTROY) closes the file and prints “closing”. This method is automatically called when the object goes out of scope, mimicking the behavior of defer in the original example.
5. In the main function, we create a FileHandler object and write to it. The file is automatically closed when the function ends and the object goes out of scope.

Running the program confirms that the file is closed after being written:

$ perl defer.pl
creating
writing
closing

This approach using object-oriented programming and destructors provides a way to ensure cleanup operations are performed, similar to the defer keyword in other languages. It’s important to note that in Perl, you should always check for errors when performing file operations, as we’ve done in the DESTROY method.