Packages
text_stemmer
0.1.0
Pre-compiled Snowball stemmers for Elixir. Ships 36 stemming algorithms covering a wide range of natural languages, accessible through a single `Text.Stemmer.stem/2` entry point.
Current section
Files
Jump to
Current section
Files
lib/text/stemmer/stemmers/romanian.ex
# Generated by Snowball.Generator — do not edit by hand.
defmodule Text.Stemmer.Stemmers.Romanian do
@moduledoc """
Snowball stemmer for romanian.
Generated from the canonical Snowball algorithm source.
"""
alias Snowball.Runtime
alias Snowball.Grouping
# Groupings
@g_v Grouping.from_string("aeiouâîă")
# Among tables
@a_0 [
{"a", -1, 1, nil},
{"e", -1, 1, nil},
{"ie", 1, 1, nil},
{"i", -1, 1, nil},
{"ă", -1, 1, nil}
]
@a_1 [
{"ea", -1, 1, nil},
{"ia", -1, 1, nil},
{"esc", -1, 1, nil},
{"ăsc", -1, 1, nil},
{"ind", -1, 1, nil},
{"ând", -1, 1, nil},
{"are", -1, 1, nil},
{"ere", -1, 1, nil},
{"ire", -1, 1, nil},
{"âre", -1, 1, nil},
{"se", -1, 2, nil},
{"ase", 10, 1, nil},
{"sese", 10, 2, nil},
{"ise", 10, 1, nil},
{"use", 10, 1, nil},
{"âse", 10, 1, nil},
{"ește", -1, 1, nil},
{"ăște", -1, 1, nil},
{"eze", -1, 1, nil},
{"ai", -1, 1, nil},
{"eai", 19, 1, nil},
{"iai", 19, 1, nil},
{"sei", -1, 2, nil},
{"ești", -1, 1, nil},
{"ăști", -1, 1, nil},
{"ui", -1, 1, nil},
{"ezi", -1, 1, nil},
{"ași", -1, 1, nil},
{"seși", -1, 2, nil},
{"aseși", 28, 1, nil},
{"seseși", 28, 2, nil},
{"iseși", 28, 1, nil},
{"useși", 28, 1, nil},
{"âseși", 28, 1, nil},
{"iși", -1, 1, nil},
{"uși", -1, 1, nil},
{"âși", -1, 1, nil},
{"ați", -1, 2, nil},
{"eați", 37, 1, nil},
{"iați", 37, 1, nil},
{"eți", -1, 2, nil},
{"iți", -1, 2, nil},
{"arăți", -1, 1, nil},
{"serăți", -1, 2, nil},
{"aserăți", 43, 1, nil},
{"seserăți", 43, 2, nil},
{"iserăți", 43, 1, nil},
{"userăți", 43, 1, nil},
{"âserăți", 43, 1, nil},
{"irăți", -1, 1, nil},
{"urăți", -1, 1, nil},
{"ârăți", -1, 1, nil},
{"âți", -1, 2, nil},
{"âi", -1, 1, nil},
{"am", -1, 1, nil},
{"eam", 54, 1, nil},
{"iam", 54, 1, nil},
{"em", -1, 2, nil},
{"asem", 57, 1, nil},
{"sesem", 57, 2, nil},
{"isem", 57, 1, nil},
{"usem", 57, 1, nil},
{"âsem", 57, 1, nil},
{"im", -1, 2, nil},
{"ăm", -1, 2, nil},
{"arăm", 64, 1, nil},
{"serăm", 64, 2, nil},
{"aserăm", 66, 1, nil},
{"seserăm", 66, 2, nil},
{"iserăm", 66, 1, nil},
{"userăm", 66, 1, nil},
{"âserăm", 66, 1, nil},
{"irăm", 64, 1, nil},
{"urăm", 64, 1, nil},
{"ârăm", 64, 1, nil},
{"âm", -1, 2, nil},
{"au", -1, 1, nil},
{"eau", 76, 1, nil},
{"iau", 76, 1, nil},
{"indu", -1, 1, nil},
{"ându", -1, 1, nil},
{"ez", -1, 1, nil},
{"ească", -1, 1, nil},
{"ară", -1, 1, nil},
{"seră", -1, 2, nil},
{"aseră", 84, 1, nil},
{"seseră", 84, 2, nil},
{"iseră", 84, 1, nil},
{"useră", 84, 1, nil},
{"âseră", 84, 1, nil},
{"iră", -1, 1, nil},
{"ură", -1, 1, nil},
{"âră", -1, 1, nil},
{"ează", -1, 1, nil}
]
@a_2 [
{"ica", -1, 1, nil},
{"abila", -1, 1, nil},
{"ibila", -1, 1, nil},
{"oasa", -1, 1, nil},
{"ata", -1, 1, nil},
{"ita", -1, 1, nil},
{"anta", -1, 1, nil},
{"ista", -1, 3, nil},
{"uta", -1, 1, nil},
{"iva", -1, 1, nil},
{"ic", -1, 1, nil},
{"ice", -1, 1, nil},
{"abile", -1, 1, nil},
{"ibile", -1, 1, nil},
{"isme", -1, 3, nil},
{"iune", -1, 2, nil},
{"oase", -1, 1, nil},
{"ate", -1, 1, nil},
{"itate", 17, 1, nil},
{"ite", -1, 1, nil},
{"ante", -1, 1, nil},
{"iste", -1, 3, nil},
{"ute", -1, 1, nil},
{"ive", -1, 1, nil},
{"ici", -1, 1, nil},
{"abili", -1, 1, nil},
{"ibili", -1, 1, nil},
{"iuni", -1, 2, nil},
{"atori", -1, 1, nil},
{"osi", -1, 1, nil},
{"ati", -1, 1, nil},
{"itati", 30, 1, nil},
{"iti", -1, 1, nil},
{"anti", -1, 1, nil},
{"isti", -1, 3, nil},
{"uti", -1, 1, nil},
{"iști", -1, 3, nil},
{"ivi", -1, 1, nil},
{"ităi", -1, 1, nil},
{"oși", -1, 1, nil},
{"ități", -1, 1, nil},
{"abil", -1, 1, nil},
{"ibil", -1, 1, nil},
{"ism", -1, 3, nil},
{"ator", -1, 1, nil},
{"os", -1, 1, nil},
{"at", -1, 1, nil},
{"it", -1, 1, nil},
{"ant", -1, 1, nil},
{"ist", -1, 3, nil},
{"ut", -1, 1, nil},
{"iv", -1, 1, nil},
{"ică", -1, 1, nil},
{"abilă", -1, 1, nil},
{"ibilă", -1, 1, nil},
{"oasă", -1, 1, nil},
{"ată", -1, 1, nil},
{"ită", -1, 1, nil},
{"antă", -1, 1, nil},
{"istă", -1, 3, nil},
{"ută", -1, 1, nil},
{"ivă", -1, 1, nil}
]
@a_3 [
{"icala", -1, 4, nil},
{"iciva", -1, 4, nil},
{"ativa", -1, 5, nil},
{"itiva", -1, 6, nil},
{"icale", -1, 4, nil},
{"ațiune", -1, 5, nil},
{"ițiune", -1, 6, nil},
{"atoare", -1, 5, nil},
{"itoare", -1, 6, nil},
{"ătoare", -1, 5, nil},
{"icitate", -1, 4, nil},
{"abilitate", -1, 1, nil},
{"ibilitate", -1, 2, nil},
{"ivitate", -1, 3, nil},
{"icive", -1, 4, nil},
{"ative", -1, 5, nil},
{"itive", -1, 6, nil},
{"icali", -1, 4, nil},
{"atori", -1, 5, nil},
{"icatori", 18, 4, nil},
{"itori", -1, 6, nil},
{"ători", -1, 5, nil},
{"icitati", -1, 4, nil},
{"abilitati", -1, 1, nil},
{"ivitati", -1, 3, nil},
{"icivi", -1, 4, nil},
{"ativi", -1, 5, nil},
{"itivi", -1, 6, nil},
{"icităi", -1, 4, nil},
{"abilităi", -1, 1, nil},
{"ivităi", -1, 3, nil},
{"icități", -1, 4, nil},
{"abilități", -1, 1, nil},
{"ivități", -1, 3, nil},
{"ical", -1, 4, nil},
{"ator", -1, 5, nil},
{"icator", 35, 4, nil},
{"itor", -1, 6, nil},
{"ător", -1, 5, nil},
{"iciv", -1, 4, nil},
{"ativ", -1, 5, nil},
{"itiv", -1, 6, nil},
{"icală", -1, 4, nil},
{"icivă", -1, 4, nil},
{"ativă", -1, 5, nil},
{"itivă", -1, 6, nil}
]
@a_4 [
{"ea", -1, 3, nil},
{"ația", -1, 7, nil},
{"aua", -1, 2, nil},
{"iua", -1, 4, nil},
{"ație", -1, 7, nil},
{"ele", -1, 3, nil},
{"ile", -1, 5, nil},
{"iile", 6, 4, nil},
{"iei", -1, 4, nil},
{"atei", -1, 6, nil},
{"ii", -1, 4, nil},
{"ului", -1, 1, nil},
{"ul", -1, 1, nil},
{"elor", -1, 3, nil},
{"ilor", -1, 4, nil},
{"iilor", 14, 4, nil}
]
@a_5 [
{"ş", -1, 1, nil},
{"ţ", -1, 2, nil}
]
@a_6 [
{"", -1, 3, nil},
{"I", 0, 1, nil},
{"U", 0, 2, nil}
]
@doc """
Stem a word.
### Arguments
* `word` is a UTF-8 binary.
### Returns
* The stemmed UTF-8 binary.
"""
@spec stem(binary()) :: binary()
def stem(word) when is_binary(word) do
state = Runtime.new(word) |> init_vars()
state = run_stem(state)
Runtime.assign_to(state)
end
defp init_vars(state), do: %{state | vars: %{p1: 0, p2: 0, pV: 0, standard_suffix_removed: false}}
defp run_stem(%Runtime{} = state) do
{_, state} = r_stem(state)
state
end
# Snowball runtime helpers.
defp snowball_do_f(state, fun) do
saved_c = state.cursor
{_, s} = fun.(state)
%{s | cursor: saved_c}
end
defp snowball_do_b(state, fun) do
rel = state.limit - state.cursor
{_, s} = fun.(state)
%{s | cursor: s.limit - rel}
end
defp snowball_test_b(state, fun) do
rel = state.limit - state.cursor
case fun.(state) do
{:ok, s} -> {:ok, %{s | cursor: s.limit - rel}}
{:fail, s} -> {:fail, %{s | cursor: s.limit - rel}}
end
end
defp snowball_or(state, fun1, fun2) do
rel = state.limit - state.cursor
case fun1.(state) do
{:ok, s} -> {:ok, s}
{:fail, s} -> fun2.(%{s | cursor: s.limit - rel})
end
end
defp lift(state, :fail), do: {:fail, state}
defp lift(_state, %Runtime{} = s), do: {:ok, s}
defp next_codepoint(%Runtime{cursor: c, limit: lim, current: cur} = state) do
case Runtime.codepoint_at(cur, c, lim) do
{_cp, size} -> {:ok, %{state | cursor: c + size}}
:error -> {:fail, state}
end
end
defp r_vowel_suffix(%Runtime{} = state) do
(fn ->
state = %{state | ket: state.cursor}
case Runtime.find_among_b(state, @a_0) do
:fail -> {:fail, state}
{%Runtime{} = s, result} ->
state = %{s | bra: s.cursor}
case (fn state ->
r_RV(state)
end).(state) do
{:ok, state} ->
case result do
1 ->
{:ok, Runtime.slice_del(state)}
_ -> {:ok, state}
end
r -> r
end
end
end).()
end
defp r_verb_suffix(%Runtime{} = state) do
(fn ->
case (fn state ->
(fn ->
target = state.vars[:pV]
if target < state.limit_backward or target > state.limit do
{:fail, state}
else
{:ok, %{state | cursor: target}}
end
end).()
end).(state) do
{:fail, _} -> {:fail, state}
{:ok, limit_state} ->
old_lb = state.limit_backward
state = %{state | limit_backward: limit_state.cursor}
case (fn state ->
(fn ->
state = %{state | ket: state.cursor}
case Runtime.find_among_b(state, @a_1) do
:fail -> {:fail, state}
{%Runtime{} = s, result} ->
state = %{s | bra: s.cursor}
case result do
1 ->
case (fn state ->
snowball_or(state,
fn state ->
lift(state, Runtime.out_grouping_b(state, @g_v))
end,
fn state ->
lift(state, Runtime.eq_s_b(state, "u"))
end)
end).(state) do
{:ok, state} ->
{:ok, Runtime.slice_del(state)}
r -> r
end
2 ->
{:ok, Runtime.slice_del(state)}
_ -> {:ok, state}
end
end
end).()
end).(state) do
{:ok, s} -> {:ok, %{s | limit_backward: old_lb}}
{:fail, s} -> {:fail, %{s | limit_backward: old_lb}}
end
end
end).()
end
defp r_standard_suffix(%Runtime{} = state) do
case (fn state ->
{:ok, put_in(state.vars[:standard_suffix_removed], false)}
end).(state) do
{:ok, state} ->
case (fn state ->
(fn loop_fn ->
loop_fn.(loop_fn, state)
end).(fn loop_fn, state ->
case (fn state ->
r_combo_suffix(state)
end).(state) do
{:ok, s} -> loop_fn.(loop_fn, s)
{:fail, s} -> {:ok, %{s | cursor: state.cursor}}
end
end)
end).(state) do
{:ok, state} ->
case (fn state ->
(fn ->
state = %{state | ket: state.cursor}
case Runtime.find_among_b(state, @a_2) do
:fail -> {:fail, state}
{%Runtime{} = s, result} ->
state = %{s | bra: s.cursor}
case (fn state ->
r_R2(state)
end).(state) do
{:ok, state} ->
case result do
1 ->
{:ok, Runtime.slice_del(state)}
2 ->
case (fn state ->
lift(state, Runtime.eq_s_b(state, "ț"))
end).(state) do
{:ok, state} ->
case (fn state ->
{:ok, %{state | bra: state.cursor}}
end).(state) do
{:ok, state} ->
{:ok, Runtime.slice_from(state, "t")}
end
r -> r
end
3 ->
{:ok, Runtime.slice_from(state, "ist")}
_ -> {:ok, state}
end
r -> r
end
end
end).()
end).(state) do
{:ok, state} ->
{:ok, put_in(state.vars[:standard_suffix_removed], true)}
r -> r
end
end
end
end
defp r_combo_suffix(%Runtime{} = state) do
snowball_test_b(state, fn state ->
case (fn state ->
(fn ->
state = %{state | ket: state.cursor}
case Runtime.find_among_b(state, @a_3) do
:fail -> {:fail, state}
{%Runtime{} = s, result} ->
state = %{s | bra: s.cursor}
case (fn state ->
r_R1(state)
end).(state) do
{:ok, state} ->
case result do
1 ->
{:ok, Runtime.slice_from(state, "abil")}
2 ->
{:ok, Runtime.slice_from(state, "ibil")}
3 ->
{:ok, Runtime.slice_from(state, "iv")}
4 ->
{:ok, Runtime.slice_from(state, "ic")}
5 ->
{:ok, Runtime.slice_from(state, "at")}
6 ->
{:ok, Runtime.slice_from(state, "it")}
_ -> {:ok, state}
end
r -> r
end
end
end).()
end).(state) do
{:ok, state} ->
{:ok, put_in(state.vars[:standard_suffix_removed], true)}
r -> r
end
end)
end
defp r_step_0(%Runtime{} = state) do
(fn ->
state = %{state | ket: state.cursor}
case Runtime.find_among_b(state, @a_4) do
:fail -> {:fail, state}
{%Runtime{} = s, result} ->
state = %{s | bra: s.cursor}
case (fn state ->
r_R1(state)
end).(state) do
{:ok, state} ->
case result do
1 ->
{:ok, Runtime.slice_del(state)}
2 ->
{:ok, Runtime.slice_from(state, "a")}
3 ->
{:ok, Runtime.slice_from(state, "e")}
4 ->
{:ok, Runtime.slice_from(state, "i")}
5 ->
case (fn state ->
(fn state ->
saved_c = state.cursor
case (fn state ->
lift(state, Runtime.eq_s_b(state, "ab"))
end).(state) do
{:ok, s} -> {:fail, %{s | cursor: saved_c}}
{:fail, s} -> {:ok, %{s | cursor: saved_c}}
end
end).(state)
end).(state) do
{:ok, state} ->
{:ok, Runtime.slice_from(state, "i")}
r -> r
end
6 ->
{:ok, Runtime.slice_from(state, "at")}
7 ->
{:ok, Runtime.slice_from(state, "ați")}
_ -> {:ok, state}
end
r -> r
end
end
end).()
end
defp r_R2(%Runtime{} = state) do
if state.vars[:p2] <= state.cursor, do: {:ok, state}, else: {:fail, state}
end
defp r_R1(%Runtime{} = state) do
if state.vars[:p1] <= state.cursor, do: {:ok, state}, else: {:fail, state}
end
defp r_RV(%Runtime{} = state) do
if state.vars[:pV] <= state.cursor, do: {:ok, state}, else: {:fail, state}
end
defp r_norm(%Runtime{} = state) do
{:ok, snowball_do_f(state, fn state ->
(fn loop_fn ->
loop_fn.(loop_fn, state)
end).(fn loop_fn, state ->
case (fn state ->
(fn loop_fn ->
loop_fn.(loop_fn, state)
end).(fn loop_fn, state ->
v = state.cursor
case (fn state ->
(fn ->
state = %{state | bra: state.cursor}
case Runtime.find_among(state, @a_5) do
:fail -> {:fail, state}
{%Runtime{} = s, result} ->
state = %{s | ket: s.cursor}
case result do
1 ->
{:ok, Runtime.slice_from(state, "ș")}
2 ->
{:ok, Runtime.slice_from(state, "ț")}
_ -> {:ok, state}
end
end
end).()
end).(state) do
{:ok, s} -> {:ok, %{s | cursor: v}}
{:fail, _} ->
case next_codepoint(%{state | cursor: v}) do
{:ok, s} -> loop_fn.(loop_fn, s)
{:fail, _} -> {:fail, state}
end
end
end)
end).(state) do
{:ok, s} -> loop_fn.(loop_fn, s)
{:fail, s} -> {:ok, %{s | cursor: state.cursor}}
end
end)
end)}
end
defp r_prelude(%Runtime{} = state) do
(fn loop_fn ->
loop_fn.(loop_fn, state)
end).(fn loop_fn, state ->
case (fn state ->
(fn loop_fn ->
loop_fn.(loop_fn, state)
end).(fn loop_fn, state ->
v = state.cursor
case (fn state ->
case (fn state ->
lift(state, Runtime.in_grouping(state, @g_v))
end).(state) do
{:ok, state} ->
case (fn state ->
{:ok, %{state | bra: state.cursor}}
end).(state) do
{:ok, state} ->
snowball_or(state,
fn state ->
case (fn state ->
lift(state, Runtime.eq_s(state, "u"))
end).(state) do
{:ok, state} ->
case (fn state ->
{:ok, %{state | ket: state.cursor}}
end).(state) do
{:ok, state} ->
case (fn state ->
lift(state, Runtime.in_grouping(state, @g_v))
end).(state) do
{:ok, state} ->
{:ok, Runtime.slice_from(state, "U")}
r -> r
end
end
r -> r
end
end,
fn state ->
case (fn state ->
lift(state, Runtime.eq_s(state, "i"))
end).(state) do
{:ok, state} ->
case (fn state ->
{:ok, %{state | ket: state.cursor}}
end).(state) do
{:ok, state} ->
case (fn state ->
lift(state, Runtime.in_grouping(state, @g_v))
end).(state) do
{:ok, state} ->
{:ok, Runtime.slice_from(state, "I")}
r -> r
end
end
r -> r
end
end)
end
r -> r
end
end).(state) do
{:ok, s} -> {:ok, %{s | cursor: v}}
{:fail, _} ->
case next_codepoint(%{state | cursor: v}) do
{:ok, s} -> loop_fn.(loop_fn, s)
{:fail, _} -> {:fail, state}
end
end
end)
end).(state) do
{:ok, s} -> loop_fn.(loop_fn, s)
{:fail, s} -> {:ok, %{s | cursor: state.cursor}}
end
end)
end
defp r_mark_regions(%Runtime{} = state) do
case (fn state ->
{:ok, put_in(state.vars[:pV], state.limit)}
end).(state) do
{:ok, state} ->
case (fn state ->
{:ok, put_in(state.vars[:p1], state.limit)}
end).(state) do
{:ok, state} ->
case (fn state ->
{:ok, put_in(state.vars[:p2], state.limit)}
end).(state) do
{:ok, state} ->
case (fn state ->
{:ok, snowball_do_f(state, fn state ->
case (fn state ->
snowball_or(state,
fn state ->
case (fn state ->
lift(state, Runtime.in_grouping(state, @g_v))
end).(state) do
{:ok, state} ->
snowball_or(state,
fn state ->
case (fn state ->
lift(state, Runtime.out_grouping(state, @g_v))
end).(state) do
{:ok, state} ->
case Runtime.go_out_grouping(state, @g_v) do
:fail -> {:fail, state}
%Runtime{} = s -> next_codepoint(s)
end
r -> r
end
end,
fn state ->
case (fn state ->
lift(state, Runtime.in_grouping(state, @g_v))
end).(state) do
{:ok, state} ->
case Runtime.go_in_grouping(state, @g_v) do
:fail -> {:fail, state}
%Runtime{} = s -> next_codepoint(s)
end
r -> r
end
end)
r -> r
end
end,
fn state ->
case (fn state ->
lift(state, Runtime.out_grouping(state, @g_v))
end).(state) do
{:ok, state} ->
snowball_or(state,
fn state ->
case (fn state ->
lift(state, Runtime.out_grouping(state, @g_v))
end).(state) do
{:ok, state} ->
case Runtime.go_out_grouping(state, @g_v) do
:fail -> {:fail, state}
%Runtime{} = s -> next_codepoint(s)
end
r -> r
end
end,
fn state ->
case (fn state ->
lift(state, Runtime.in_grouping(state, @g_v))
end).(state) do
{:ok, state} ->
next_codepoint(state)
r -> r
end
end)
r -> r
end
end)
end).(state) do
{:ok, state} ->
{:ok, put_in(state.vars[:pV], state.cursor)}
r -> r
end
end)}
end).(state) do
{:ok, state} ->
{:ok, snowball_do_f(state, fn state ->
case (fn state ->
case Runtime.go_out_grouping(state, @g_v) do
:fail -> {:fail, state}
%Runtime{} = s -> next_codepoint(s)
end
end).(state) do
{:ok, state} ->
case (fn state ->
case Runtime.go_in_grouping(state, @g_v) do
:fail -> {:fail, state}
%Runtime{} = s -> next_codepoint(s)
end
end).(state) do
{:ok, state} ->
case (fn state ->
{:ok, put_in(state.vars[:p1], state.cursor)}
end).(state) do
{:ok, state} ->
case (fn state ->
case Runtime.go_out_grouping(state, @g_v) do
:fail -> {:fail, state}
%Runtime{} = s -> next_codepoint(s)
end
end).(state) do
{:ok, state} ->
case (fn state ->
case Runtime.go_in_grouping(state, @g_v) do
:fail -> {:fail, state}
%Runtime{} = s -> next_codepoint(s)
end
end).(state) do
{:ok, state} ->
{:ok, put_in(state.vars[:p2], state.cursor)}
r -> r
end
r -> r
end
end
r -> r
end
r -> r
end
end)}
end
end
end
end
end
defp r_postlude(%Runtime{} = state) do
(fn loop_fn ->
loop_fn.(loop_fn, state)
end).(fn loop_fn, state ->
case (fn state ->
(fn ->
state = %{state | bra: state.cursor}
case Runtime.find_among(state, @a_6) do
:fail -> {:fail, state}
{%Runtime{} = s, result} ->
state = %{s | ket: s.cursor}
case result do
1 ->
{:ok, Runtime.slice_from(state, "i")}
2 ->
{:ok, Runtime.slice_from(state, "u")}
3 ->
next_codepoint(state)
_ -> {:ok, state}
end
end
end).()
end).(state) do
{:ok, s} -> loop_fn.(loop_fn, s)
{:fail, s} -> {:ok, %{s | cursor: state.cursor}}
end
end)
end
defp r_stem(%Runtime{} = state) do
case (fn state ->
{:ok, snowball_do_f(state, fn state ->
r_norm(state)
end)}
end).(state) do
{:ok, state} ->
case (fn state ->
{:ok, snowball_do_f(state, fn state ->
r_prelude(state)
end)}
end).(state) do
{:ok, state} ->
case (fn state ->
{:ok, snowball_do_f(state, fn state ->
r_mark_regions(state)
end)}
end).(state) do
{:ok, state} ->
case (fn state ->
(fn state ->
old_cursor = state.cursor
old_lb = state.limit_backward
state = %{state | cursor: state.limit, limit_backward: old_cursor}
{tag, s} = (fn state ->
case (fn state ->
{:ok, snowball_do_b(state, fn state ->
r_step_0(state)
end)}
end).(state) do
{:ok, state} ->
case (fn state ->
{:ok, snowball_do_b(state, fn state ->
r_standard_suffix(state)
end)}
end).(state) do
{:ok, state} ->
case (fn state ->
{:ok, snowball_do_b(state, fn state ->
snowball_or(state,
fn state ->
if state.vars[:standard_suffix_removed], do: {:ok, state}, else: {:fail, state}
end,
fn state ->
r_verb_suffix(state)
end)
end)}
end).(state) do
{:ok, state} ->
{:ok, snowball_do_b(state, fn state ->
r_vowel_suffix(state)
end)}
end
end
end
end).(state)
{tag, %{s | cursor: old_cursor, limit_backward: old_lb}}
end).(state)
end).(state) do
{:ok, state} ->
{:ok, snowball_do_f(state, fn state ->
r_postlude(state)
end)}
end
end
end
end
end
end