gradebook.pl

# foreach with a named variable — preferred for readability
for my $student (@students) {
    printf "%-18s  avg:%5.1f  %s\n",
        $student{name}, $student{avg},
        ($student{pass} ? "passing" : "FAILING");
}

# C-style for — useful when you need the index
for (my $i = 0; $i < @students; $i++) {
    say "[$$i] $students[$i]{name}";
}

# while — condition checked before each iteration
while (my $line = <STDIN>) {
    chomp $line;
    last if $line eq 'quit';  # break out of loop
    next unless $line;         # skip empty lines
    say "  Got: $line";
}

# Postfix for — neat one-liners
say "  $_" for @names;   # $_ = each element

# Labels for nested loop control
STUDENT: for my $s (@students) {
    for my $score (@{$s{scores}}) {
        if ($score < 65) {
            say "at risk: $s{name}";
            next STUDENT;   # jump to next $s
        }
    }
}

# map: transform — runs block once per element, returns new list
my @all_avgs = map {
    my @s = @{ $_{scores} };   # $_ = current student hash
    calculate_average(@s)
} @students;

# grep: filter — keeps elements where block returns true
my @passing   = grep { $_{pass}        } @students;
my @honor     = grep { $_{avg} >= 90  } @students;
my @failing   = grep { !$_{pass}       } @students;

# sort with a comparison block ($a and $b are special)
my @ranked = sort { $b{avg} <=> $a{avg} } @students;

# Schwartzian Transform: efficient sort by computed key
# 1. map: attach the key   2. sort   3. map: strip it off
my @by_best = map  { $_[0] }
              sort { $b[1] <=> $a[1] }
              map  { [$_, max(@{$_{scores}})] }
              @students;

# Build a frequency hash with map + a loop
my %grade_count;
$grade_count{ $_{grade} }++ for @students;

# Grade distribution bar chart
for my $g (sort keys %grade_count) {
    my $bar = "█" x $grade_count{$g};
    printf "  %s: %s (%d)\n", $g, $bar, $grade_count{$g};
}

# =~ tests a match. !~ tests non-match.
if ($email =~  /\@/)  { say "has @"    }
if ($email !~  /\d/)  { say "no digits" }

# /g in list context returns ALL matches as a list
my @caps = ($text =~ /\b[A-Z]{2,}\b/g);
say join(", ", @caps);   # ALICE, MATH

# Capture groups ( ) → $1, $2, ...
if ($name =~ /^(\w+)\s+(.+)$/) {
    my ($first, $last) = ($1, $2);
}

# Named captures (?<name>) → %+
if ($date =~ /(?<y>\d{4})-(?<m>\d{2})-(?<d>\d{2})/) {
    say "Year: $+{y}  Month: $+{m}";
}

# Substitution: s/PATTERN/REPLACEMENT/flags
$str =~ s/foo/bar/;        # replace first
$str =~ s/foo/bar/g;       # replace all
$str =~ s/foo/bar/gi;      # global + case-insensitive

# /r flag: return copy instead of modifying $str
my $new = $str =~ s/old/new/gr;

# /e flag: evaluate replacement as Perl code
$str =~ s/(\d+)/$1*2/ge;   # double every number

# Fix ALLCAPS to Title Case
(my $clean = $text) =~ s/\b([A-Z]+)\b/\u\L$1/g;

# tr///: character mapping (not regex — char-by-char)
$str =~ tr/a-z/A-Z/;          # uppercase all
my $vowels = ($str =~ tr/aeiou//); # count vowels
$str =~ tr/aeiou//d;            # /d = delete matches

# Creating references
my $aref = \@array;           # reference to existing array
my $href = \%hash;            # reference to existing hash
my $anon = [1, 2, 3];          # anonymous arrayref
my $rec  = {name => "Alice"};  # anonymous hashref

# Arrow notation to dereference
say $aref->[0];           # array element via ref
say $rec->{name};          # hash value via ref

# @{} and %{} dereference the whole structure
my @copy = @{$aref};

# ref() returns the type of reference
say ref($aref);           # "ARRAY"
say ref($rec);            # "HASH"

# Code references — storing subs in variables (lambdas)
my $square = sub { $_[0] ** 2 };
say $square->(5);         # 25

# Dispatch table: hash of code refs
my %actions = (
    'A' => sub { "Excellent!"           },
    'B' => sub { "Good job."             },
    'F' => sub { "Please see me."        },
);
my $msg = $actions{ $grade }->();  # call by grade letter

# Passing by reference — modifies the original
sub double_all {
    my ($ref) = @_;
    $_ *= 2 for @{$ref};
}
double_all(\@scores);   # @scores is modified

# Writing — '>' truncates, '>>' appends, '<' reads
open(my $fh, '>',  'report.txt') or die $!;
open(my $fh, '>>', 'log.txt')  or die $!;
open(my $fh, '<', 'data.txt')  or die $!;

# Writing: print to a filehandle (no comma!)
print $fh "line of text\n";
printf $fh "%-15s %s\n", "Label:", $value;

# Reading line by line — most memory-efficient
while (my $line = <$fh>) {
    chomp $line;   # removes trailing newline
    # process $line...
}

# Slurp all lines into an array
my @lines = <$fh>;
chomp @lines;      # chomp works on arrays too

# Slurp entire file into one string
my $content = do { local $/; <$fh> };
# local $/ = undef disables line-splitting for this block

close $fh;         # always close when done

# Diamond <> reads from @ARGV files or STDIN
while (<>) { print }   # cat-like: prints every line

# File test operators — check without opening
-e $path    # exists
-f $path    # is a plain file (not dir, symlink...)
-d $path    # is a directory
-r $path    # readable by current user
-s $path    # file size in bytes
-M $path    # age in days since last modification

package Student;
use parent  # for inheritance later

# Constructor — 'new' is convention, any name works
sub new {
    my ($class, %args) = @_;   # $class = "Student"
    die "name required\n"  unless defined $args{name};
    my $self = {
        name   => $args{name},
        email  => $args{email},
        scores => $args{scores} // [],
    };
    return bless $self, $class;  # bless makes it an object
}

# Accessor: get/set name
sub name {
    my ($self, $new) = @_;
    $self->{name} = $new if defined $new;
    return $self->{name};
}

# Method chaining: return $self to chain calls
sub add_score {
    my ($self, $score) = @_;
    push @{ $self->{scores} }, $score;
    return $self;   # enables chaining
}

# --- Subclass with inheritance ---
package HonorsStudent;
use parent -norequire, 'Student';

sub new {
    my ($class, %args) = @_;
    my $self = $class->SUPER::new(%args);  # call Student::new
    $self->{bonus} = $args{bonus} // 5;
    return $self;
}

package main;

# Method chaining
my $s = Student->new(name => "Grace", email => 'g@s.edu')
         ->add_score(88)->add_score(92)->add_score(95);

ref($s);                   # "Student"
$s->isa('Student');        # 1 = true
$s->can('add_score');     # coderef or undef

# $_ in action — used implicitly
my @words = qw(apple BANANA cherry);
for (@words) {
    $_ = lc;    # lc with no args operates on $_
    print;     # print with no args prints $_
}

# wantarray: detect caller's context
sub flexible {
    return wantarray ? (1,2,3) : "all-in-one";
}
my @list   = flexible();  # list context  → (1, 2, 3)
my $scalar = flexible();  # scalar context → "all-in-one"

# Context affects built-ins too
my @arr    = (5,3,8,1);
my $count  = @arr;        # 4 — scalar context = count
my ($first) = @arr;       # 5 — list context (parens!) = first element

# Command-line args and environment
my $arg1  = $ARGV[0] // "default";
my $home  = $ENV{HOME};
my $path  = $ENV{PATH};