# When you call a method, you do so with an invocant. 
# When you call a method on an object, that object is the invocant:
my $choco = Cat->new;
$choco->sleep_on_keyboard;

# A method's first argument is its invocant($self). Suppose a Cat can meow():
package Cat {
  use Moose;
  
  sub meow {
    my $self = shift;
    say 'Meow!';
  }
}
# the cat always meows three times at 6 am 
my $fuzzy_alarm = Cat->new;
$fuzzy_alarm->meow for 1..3;

\!h # This is an experimental feature, not using it properly might warrant confusing results. 
\!h # Stick to simple operations between two operands.

use experimental 'smartmatch';
say 'They match (somehow)' if $l_operand ~~ $r_operand; 
 
# The type of comparsion usually depends first on the type of the right operand then on the left.
# Scalar with numeric component --> numeric equality
# Regex --> a grep or a pattern match
# Array --> a grep or a recursive smart match
# Hash --> checks existence of one or more keys 
# ... more on perldoc perlsyn

# Simple example with case sensitivity:
my $pet = 'ELLie';

like $pet, qr/Ellie/, 'Nice Puppy!'; # won't work
like $pet, qr/Ellie/i, 'shift key brOken'; # works because of /i modifier which ignores case

# Embed regex modifiers within a pattern:
my $find_a_cat = qr/(?<feline>(?i)cat)/; # enables case-insensitive matching only for its enclosing group - here, its the named capture
# To disable specific modifiers, precede them with the minus character:
my $find_a_rational = qr/(?<number>(?-i)Rat)/;

\!h # The multiline operator (/m) - allows the ^ and $ anchors to match at any newline embedded within the string
\!h # The /s modifier treats the source string as a single line such as that the '.' metacharacter matches the newline character.
# i.e. /m modifies the behaviour of multiple regex metacharacters, while /s modifies that of a single one.

my ($text, $literal_text) = @_;
return $text =~ /\Q$literal_text\E/;

# To match apple or orange:
/apple|orange/

# Perl tries to match the first possible position:
"apple and orange" =~ '/apple|orange|mango/'; # matches apple
"apple and orange" =~ '/orange|apple|mango/'; # matches orange

\!h # Grouping 
# the issue with regular alternation is that you have to repeat words sometimes:
/housemate|housemaid|houseman/
# grouping solves this issue with parentheses:
/house(mate|maid|man)

# Full example - grouping metacharacter in regular expression:
#!/usr/bin/perl
use warnings;
use strict;
 my @words = ('housemaid',
        'housemate',
        'household', 
        'houseman',
        'house');
        
for (@words) {
  print("$_\n") if(/house(maid|mate|man)/);
}
  
  
}

\!h # Example - extract an American telephone number of the form (202)456-1111:
my $area_code = qr/\(\d{3)\)/; # escaped parentheses
my $local_number = qr /\d {3}-?\d{4}/;
my $phone_number = qr/$area\s?$local_number/;

\!h # Named captures - capture portions of matches from applying a regex and access them later.
# Example - extracting a phone number from contact information:
if ($contact_info =~ /(?<phone>$phone_number)/) {
  say "Found a number $+{phone}";
}

# Named capture syntax: 
(?<capture name> ...)
# the ?<name> construct immediately follows the opening parentheses and provides a name for this particular capture
# the rest of the capture is the regular expression

\!h # Numbered Captures 
if ($contact_info =~ /($phone_number)/) {
  say "Found a number $1";
}
# Perl stores the captured substring in a series of magic variables. 
# The first matching capture goes into $1, the second into $2, and so on.

# Basic character class
my $ascii_vowels = qr/[aeiou]/;
my $maybe_cat = qr/c${ascii_vowels}t/;

# The hyphen allows you to include a continous range of characters in a class:
my $ascii_letters_only = qr/[a-zA-Z]/;
# Alternatively, have the hyphen as a member of the class by placing it at the start or the end of the class:
my $interesting_punctuaction = qr/[-!?]/;
# or escape it:
my $line_characters = qr/[|=\-_]/;

# Use the caret(^) at the start of the class to mean 'anything except these characters'
my $not_an_ascii_vowel = qr/[^aeiou]/;

# The start of string anchor (\A) dictates that a match must start at the beginning of the string:
# also matches "lammed", "lawmaker" and "layman"
my $seven_down = qr/\Al${letters_only}{2}m/; # (letter 'l' and 'm')

# The end of line string anchor (\z) requires that a match ends at the end of the string:
# also matches "loom", still an obvious improvement
my $seven_down = qr/\Al${letters_only}{2}m\z/; 

\!h # There are also the ^ and $ assertions used to match the start and end of strings
# ^ does mean the start of the string, but in certain circumstances it can match the invisible point after the newline within the string

# Example:
# You want to find strings that have 'barney' at the absolute beginning of the string or anywhere after a newline.
/^barney/m

\!h # Similarly, $ does mean the end of the string, 
# but it can match the invisible point before a newline in the middle of the string

# Example:
# You want to find strings that have 'fred' at the end of any line, not just at the end of the entire string.
/fred$/m

\!h # Without the '/m', ^ and $ act just like \A and \Z. Its better to use \A and \Z unless you specifically want multiline matching.

\!h # Word Anchors

# The word-boundary anchor, \b, matching either end of the word.
# For example, /\bfred\b/ will match the word 'fred', but not ones like 'frederick', 'alfred', or 'manfred'.

# This is useful to ensure you dont find 'cat' in 'delicatessen', or 'fish' in 'selfishness'.
# You would normally use one word-boundary anchor, when using /\bhunt\ to match words like 'hunt' or 'hunting', but not 'shunt'.
# Or when using /stone\b/ to match words like 'sandstone' or 'flintstone', but not 'capstones'.

# The nonword-boundary anchor, \B, matching any point \b wouldn't match. 
# For example, the pattern /\bsearch\B/ will match 'searches' or 'searching', but not 'search' or 'researching'.

# A poor regex 
my $hot_meal = qr/hot.*meal/;
say 'Found a hot meal!' if 'I have a hot meal' =~ $hot_meal;
say 'Found a hot meal!' if 'one-shot, piecemeal work!' =~ $hot_meal;
# ^ Greedy quantifers start by matching everything at first.

\!h # To get around this, the ? can turn a greedy quantifier non greedy:
my $minimal_greedy = qr/hot.*?meal/;
# With the modification above, the regex engine will prefer the shortest possible match. 
# If that match fails, it will increase the number of characters identified by one character at a time.

\!h # There are three main quantifiers:
- ? matching 0 or 1 occurence 
- + matching 1 or more occurence 
- * matching 0 or more (i.e. any amount)

# In addition to that, using curly braces we can have even more flexible quantifiers

\!h # Example: color vs colour - optional characters
# the long way
if ($str =~ /color/ or $str =~ /colour/) {
  ...
}
# faster way with a quantifier
if ($str =~ /colou?r/) {
  ...
}
# Here, the ? says the letter 'u' can appear 0 or 1 times.
# Therefore, either 'color' or 'colour' will work.

\!h # The curly braces:
# These can be used to express alot of differnt amounts.
# Normally, they are used to express a range:
x{2, 4} would mean 2, 3 or 4 x-es
# removing the upper limit:
x{2,} would mean 2 or more x-es
# removing the comma:
x{2} would mean exactly 2 x-es

\!h # Quantifiers on character classes
# As well as individual characters, we can also use quantifiers on special characters or character classes
/[0-9]+/ meaning 1 or more digits
/[0-9]{2-4}/ meaning 2 to 4 digits
/-[abc]+-/ meaning 1 or more occurences of a, b or c between two dashes
# as a comparison, the character class /-[abc]-/ (without the quantifier), will match:
-a- 
-b- 
# but not:
-aa-
-ab-
--
-x-
# with the quantifier it will match:
-a-
-b-
-aa-
-ab-
# but not:
--
-x-
# with an * in place of the + it will match an empty field -- but still not a different character -x-