Subroutines

🔧 Subroutines

📐 Defining and Calling a Subroutine

Copysub greet {
    say "Hello!";
}

greet();   # Hello!

You may occasionally see the older &greet(); call syntax in legacy code — it still works, but plain greet(); is the standard modern form and what real code should use.

📦 @_ — Arguments Arrive as a Single Array

Copysub add {
    my ($a, $b) = @_;   # unpack @_ into named scalars — the standard idiom
    return $a + $b;
}

say add(3, 4);   # 7

Every argument passed to a subroutine — however many there are — lands in the array @_, exactly like Chapter 3's arrays. my ($a, $b) = @_; is a list assignment (also Chapter 3) unpacking the first two elements into named scalars — this line, or a close variant of it, is the first line of nearly every real Perl subroutine.

🔢 Default Values & Variable Argument Counts

Copysub greet_user {
    my ($name, $greeting) = @_;
    $greeting //= "Hello";   # //= — assign only if $greeting is undef
    say "$greeting, $name!";
}

greet_user("Ada");              # Hello, Ada!  — $greeting was never passed, so it's undef, then defaulted
greet_user("Ada", "Hi");        # Hi, Ada!

say scalar(@_);   # inside any sub, tells you exactly how many arguments were passed

//= ("defined-or assign") only assigns if the left side is currently undef — the idiomatic way to supply a default for a missing argument, since a genuinely passed value of 0 or "" (falsy, but defined) is correctly left alone, unlike the similar-looking ||=, which would incorrectly overwrite those too.

↩️ Return Values

Copysub square {
    my ($n) = @_;
    return $n * $n;
}

sub square_implicit {
    my ($n) = @_;
    $n * $n;   # no explicit return — the last evaluated expression is returned automatically
}

Both subroutines above behave identically. Perl, like Ruby, returns the value of the last evaluated expression automatically if no explicit return is reached — genuinely convenient for short subroutines, though an explicit return is usually clearer once a subroutine has more than one possible exit point.

🎭 Context-Sensitive Return — wantarray

This is Chapter 3's list-vs-scalar-context theme taken to its logical extreme: a subroutine can inspect how it was called and return something different accordingly, using wantarray().

Copysub get_scores {
    my @scores = (85, 92, 78);

    if (wantarray()) {
        return @scores;             # called in LIST context — return every score
    } else {
        return scalar(@scores);   # called in SCALAR context — return just the count
    }
}

my @all   = get_scores();   # (85, 92, 78) — list context
my $count = get_scores();   # 3            — scalar context

wantarray() returns a true value if the subroutine was called in list context, a defined-but-false value in scalar context, and undef in void context (called for its side effects, with the return value discarded entirely) — three genuinely distinguishable answers, not just a boolean.

🔗 Passing Arguments by Reference (Preview)

Copysub double_it {
    $_[0] *= 2;   # modifies the CALLER's original variable, not a local copy!
}

my $x = 5;
double_it($x);
say $x;   # 10 — $x itself changed, even though it wasn't explicitly passed "by reference"

🔧 A Worked Example

Copysub format_price {
    my ($amount, $currency) = @_;
    $currency //= "USD";

    return sprintf("%.2f %s", $amount, $currency);
}

say format_price(19.9);          # 19.90 USD
say format_price(19.9, "EUR");    # 19.90 EUR

💻 Coding Challenges

🎯 What's Next

Next chapter: File I/O & Text Processing — open/close, the while (<FH>) idiom, and Perl's original "practical extraction and report" purpose.