Image

head

code

root

para

L<Examples| file:../examples/index.podlite>


L<Download |file:../download/index.podlite>


React

=begin React :component<HeaderCol> :id<menu> 
=para L<Documentation|/doc/introduction>
=para L<Modules| /mods>
=para L<Examples| file:../examples/index.podlite>
=para L<Download |file:../download/index.podlite>
=para L<About|file:../about/index.podlite>
=para 🔍 K<⌘K>/K<ctrl-K>
=end React


HEADER

FOOTER

README

comment

=begin comment

# each vowel-group indicates a syllable, except for:
#  final (silent) e
#  'ia' ind two syl 

# @AddSyl and @SubSyl list regexps to massage the basic count.
# Each match from @AddSyl adds 1 to the basic count, each @SubSyl match -1
# Keep in mind that when the regexps are checked, any final 'e' will have
# been removed, and all '\'' will have been removed.

=end comment



unit module Lingua::EN::Syllable;

my @SubSyl =
    / 'cial' /,
    / 'tia' /,
    / 'cius' /,
    / 'cious' /,
    / 'giu' /,              # belgium!
    / 'ion' /,
    / 'iou' /,
    / 'sia' $ /,
    / . 'ely' $ / ,         # absolutely! (but not ely!)
;

my @AddSyl =
    / 'ia' /,
    / 'riet' /,
    / 'dien' /,
    / 'iu' /,
    / 'io' /,
    / 'ii' /,
    / <[aeiouym]> 'bl' $/,     # -Vble, plus -mble
    / <[aeiou]> ** 3/,       # agreeable
    /^ 'mc' /,
    / 'ism' $ /,             # -isms
    / (<-[aeiouy]>) $0 'l' $/,  # middle twiddle battle bottle, etc.
    / <-[l]> lien/,         # alien, salient [1]
    / ^ 'coa' <[dglx]> . / ,      # [2]
    / <-[gq]> 'ua' <-[auieo]>/,  # i think this fixes more than it breaks
    / 'dnt' $/,           # couldn't
;

# (comments refer to titan's /usr/dict/words)
# [1] alien, salient, but not lien or ebbullient...
#     (those are the only 2 exceptions i found, there may be others)
# [2] exception for 7 words:
#     coadjutor coagulable coagulate coalesce coalescent coalition coaxial

sub syllable($word is copy) is export {
    # fold contractions, remove silent e
    $word = $word.lc.subst("'", "").subst(/ 'e' $/ , "");

    # count vowel groupings, track special cases
    my $syl = $word.comb(/<[aeiouy]>+/) 
              + @AddSyl.grep(-> $re { $word ~~ $re })
              - @SubSyl.grep(-> $re { $word ~~ $re });

    # Every word has at least one syllable
    return max($syl, 1);
}



Syllable

my regex c {                  # A consonant
    [
    || <-[aeiou]>             # not any of "aeiou" and
    || <?after <[aeiou]>> y   # "y" only if preceded by "aeiou"
    || << y                   # or if at the start of a word
    ]
}

my regex C { <c>+ } # Consonant cluster

my regex V { <v>+ } # Vowel cluster

my regex v {                  # A vowel
    [
    || <[aeiou]>              # "aeiou" and
    || [<!after <[aeiou]>> y] # "y" if not preceded by a "aeiou"
    ]
}

my regex mgt0 {
    ^
    [<c>+]?
    [<v>+ <c>+] ** 1..*
    [<v>+]?
    $
}
my regex mgt1 {
    ^
    [<c>+]?
    [<v>+ <c>+] ** 2..*
    [<v>+]?
    $
}
my regex meq1 {
    ^
    [<c>+]?
    [<v>+ <c>+] ** 1
    [<v>+]?
    $
}

my constant %step2hash =
  ational  => "ate",
  tional   => "tion",
  enci     => "ence",
  anci     => "ance",
  izer     => "ize",
  bli      => "ble",
  alli     => "al",
  entli    => "ent",
  eli      => "e",
  ousli    => "ous",
  ization  => "ize",
  ation    => "ate",
  ator     => "ate",
  alism    => "al",
  iveness  => "ive",
  fulness  => "ful",
  ousness  => "ous",
  aliti    => "al",
  iviti    => "ive",
  biliti   => "ble",
  logi     => "log",
;

my constant %step3hash = 
  icate => 'ic',
  ative => '',
  alize => 'al',
  iciti => 'ic',
  ical  => 'ic',
  ful   => '',
  ness  => '',
;

#| This subroutine uses the Porter stemming algorithm to stem a given word
sub porter(
  Str:D $word is copy #= The word to be stemmed
--> Str:D) is export {

    if $word.chars > 2 {
        # Step 1a
        if $word ~~ /[(ss||i)es||(<-[s]>)s]$/ {
            $word = $/.prematch ~ $0;
        }

        # Step 1b
        if $word ~~ /eed$/ {
            if $/.prematch ~~ /<mgt0>/ {
                $word .= chop;
            }
        }
        elsif $word ~~ /(ed||ing)$/ {
            my $stem = $/.prematch;
            if $stem ~~ /<v>/ {
                $word = $stem;
                if    $word ~~ /[at||bl||iz]$/         { $word ~= "e"; }
                elsif $word ~~ /(<-[aeiouylsz]>)$0$/   { $word .= chop; }
                elsif $word ~~ /^<C><v><-[aeiouwxy]>$/ { $word ~= "e"; }
            }
        }

        # Step 1c
        if $word ~~ /y$/ {
            my $stem = $/.prematch;
            if $stem ~~ /<v>/ {
                $word = $stem ~ "i";
            }
        }

        # Step 2
        if $word ~~ /(
          ational||tional||enci||anci||izer||bli||alli||entli||eli||ousli||ization
            ||ation||ator||alism||iveness||fulness||ousness||aliti||iviti||biliti||logi
        )$/ {
            my $stem   = $/.prematch;
            my $suffix = ~$0;
            if $stem ~~ /<mgt0>/ {
                $word = $stem ~ %step2hash{$suffix};
            }
        }

        # Step 3
        if $word ~~ /(icate||ative||alize||iciti||ical||ful||ness)$/ {
            my $stem   = $/.prematch;
            my $suffix = ~$0;
            if $stem ~~ /<mgt0>/ {
                $word = $stem ~ %step3hash{$suffix};
            }
        }

        # Step 4
        if $word ~~ /(
          al||ance||ence||er||ic||able||ible||ant||ement||ment||ent||ou
          ||ism||ate||iti||ous||ive||ize
        )$/ {
            my $stem = $/.prematch;
            if $stem ~~ /<mgt1>/ {
                $word = $stem;
            }
        }
        elsif $word ~~ /(s||t)(ion)$/ {
            my $stem = $/.prematch ~ $0;
            if $stem ~~ /<mgt1>/ {
                $word = $stem;
            }
        }

        # Step 5
        if $word ~~ /e$/ {
            my $stem = $/.prematch;
            if $stem ~~ /<mgt1>/
              || ($stem ~~ /<meq1>/ && not $stem ~~ /^<C><v><-[aeiouwxy]>$/) {
                $word = $stem;
            }
        }
        if $word ~~ /ll$/ && $word ~~ /<mgt1>/ {
            $word .= chop;
        }
    }
    $word
}



Lingua::EN::Stem::Porter - Implementation of the Porter stemming algorithm


=begin code :lang<raku>

use Lingua::EN::Stem::Porter;

say porter("establishment");  # establish

=end code


Lingua::EN::Stem::Porter implements the Porter stemming algorithm by
exporting a single subroutone C<porter> which takes an English word and
returns the stem given by the Porter algorithm.


This library is free software; you can redistribute it and/or modify it under the MIT License 2.0.


Porter

The Raku Knowledge Base


=begin React :component<HeaderCol> :id<footer>  
=begin nested :!nested
=item1 B<Language>
    =item2 L<Get started|file:../getting-started/getting-started.podlite>
    =item2 L<Why Raku?|/doc/language/faq#Why-should-I-learn-Raku-What's-so-great-about-it>
    =item2 L<Try Raku|https://glot.io/new/raku>
    =item2 L<Raku cheat sheet|https://github.com/Raku/mu/blob/master/docs/Perl6/Cheatsheet/cheatsheet.txt>
    =item2 L<empty|#>
    =item2 L<empty|#>
    =item2 L<empty|#>
    =item2 L<Raku on Exercism|https://exercism.org/tracks/raku>
    =item2 L<Wikipedia|https://en.wikipedia.org/wiki/Raku_(programming_language)>
    =item2 L<empty|#>
    =item2 L<empty|#>
    =item2 L<empty|#>

=end nested
=begin nested :!nested

=item1 B<L<Documentation|/doc>>
    =item2 L<Getting started, Migration guides from other languages, & Tutorials | file:../doc/introduction.podlite>
    =item2 L<Language References|file:../doc/reference.podlite>
    =item2 L<Type Reference| file:../doc/types.podlite>
    =item2 L<Miscellaneous| file:../doc/miscellaneous.podlite>
    =item2 L<FAQs (Frequently Asked Questions)|/doc/language/faq>
    =item2 L<Community|/doc/language/community>
    =item2 L<The list of all documents|file:../doc/index.podlite>

=item1 B<Resources>
    =item2 L<The Raku Guide|https://raku.guide/>
    =item2 L<Books |https://perl6book.com/>
    =item2 L<Rosetta Code | https://www.raku.org/community/rosettacode>

=end nested
=begin nested :!nested

=item1 B<Resoures>
    =item2 L<Download | file:../download/index.podlite>
    =item2 L<empty|#>
    =item2 L<empty|#>
    =item2 L<empty|#>
    =item2 L<empty|#>
    =item2 L<empty|#>
    =item2 L<empty|#>
    =item2 L<empty|#>

=item1 B<Learning>
    =item2 L<The Raku Guide|https://raku.guide/>
    =item2 L<Wikibook |https://en.wikibooks.org/wiki/Raku_Programming>
    =item2 L<Books |https://perl6book.com/>
    =item2 L<Rosetta Code | https://www.raku.org/community/rosettacode>
    =item2 L<Learn Raku in Y minutes|https://learnxinyminutes.com/docs/raku/>
    =item2 L<Golfing |https://github.com/AlexDaniel/raku-golf-cheatsheet>
=end nested
=begin nested :!nested

=item1 B<Explore>
    =item2 L<Raku Blog Aggregator|https://planet.raku.org/>
    =item2 L<Rakudo Weekly|https://rakudoweekly.blog/>
    =item2 L<The Weekly Challenge |https://perlweeklychallenge.org/>
    =item2 L<Raku Advent Calendar|https://raku-advent.blog/>
    =item2 L<empty|#>
    =item2 L<empty|#>
    =item2 L<empty|#>
    =item2 L<empty|#>
    =item2 L<empty|#>

=end nested
=end React


=begin React :component<CookieConsent> :id<CookieConsent> :buttonCaption("Got it!")
=para
This website uses cookies for analytics.
=end React


README

sub porter

class Mu $

NAME

SYNOPSIS

DESCRIPTION

AUTHOR

COPYRIGHT AND LICENSE

Lingua::EN::Stem::Porter v1.1

Authors

License

Dependencies

Test Dependencies

Provides

Documentation