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/estonian.ex
# Generated by Snowball.Generator — do not edit by hand.
defmodule Text.Stemmer.Stemmers.Estonian do
@moduledoc """
Snowball stemmer for estonian.
Generated from the canonical Snowball algorithm source.
"""
alias Snowball.Runtime
alias Snowball.Grouping
# Groupings
@g_GI Grouping.from_string("cjlmnqrvwxaeiouõäöü")
@g_KI Grouping.from_string("kptgbdshfšzž")
@g_RV Grouping.from_string("aeiuo")
@g_V1 Grouping.from_string("aeiouõäöü")
# Among tables
@a_0 [
{"ma", -1, 2, nil},
{"mai", -1, 1, nil},
{"m", -1, 3, nil}
]
@a_1 [
{"kk", -1, 1, nil},
{"pp", -1, 2, nil},
{"tt", -1, 3, nil}
]
@a_2 [
{"va", -1, -1, nil},
{"du", -1, -1, nil},
{"nu", -1, -1, nil},
{"tu", -1, -1, nil}
]
@a_3 [
{"", -1, 2, nil},
{"las", 0, 1, nil},
{"lis", 0, 1, nil},
{"mis", 0, 1, nil},
{"t", 0, -1, nil}
]
@a_4 [
{"d", -1, 7, nil},
{"sid", 0, 4, nil},
{"de", -1, 6, nil},
{"ikkude", 2, 1, nil},
{"ike", -1, 3, nil},
{"ikke", -1, 2, nil},
{"te", -1, 5, nil}
]
@a_5 [
{"ga", -1, 5, nil},
{"ta", -1, 7, nil},
{"le", -1, 3, nil},
{"sse", -1, 1, nil},
{"l", -1, 10, nil},
{"s", -1, 9, nil},
{"ks", 5, 6, nil},
{"t", -1, 8, nil},
{"lt", 7, 4, nil},
{"st", 7, 2, nil}
]
@a_6 [
{"lane", -1, 3, nil},
{"line", -1, 11, nil},
{"mine", -1, 7, nil},
{"lasse", -1, 1, nil},
{"lisse", -1, 9, nil},
{"misse", -1, 5, nil},
{"lasi", -1, 4, nil},
{"lisi", -1, 12, nil},
{"misi", -1, 8, nil},
{"last", -1, 2, nil},
{"list", -1, 10, nil},
{"mist", -1, 6, nil}
]
@a_7 [
{"i", -1, 1, nil}
]
@a_8 [
{"aa", -1, -1, nil},
{"ee", -1, -1, nil},
{"ii", -1, -1, nil},
{"oo", -1, -1, nil},
{"uu", -1, -1, nil},
{"ää", -1, -1, nil},
{"õõ", -1, -1, nil},
{"öö", -1, -1, nil},
{"üü", -1, -1, nil}
]
@a_9 [
{"da", -1, 11, nil},
{"mata", -1, 3, nil},
{"b", -1, 13, nil},
{"ksid", -1, 2, nil},
{"nuksid", 3, 1, nil},
{"me", -1, 10, nil},
{"sime", 5, 7, nil},
{"ksime", 6, 2, nil},
{"nuksime", 7, 1, nil},
{"akse", -1, 6, nil},
{"dakse", 9, 4, nil},
{"takse", 9, 4, nil},
{"site", -1, 8, nil},
{"ksite", 12, 2, nil},
{"nuksite", 13, 1, nil},
{"n", -1, 12, nil},
{"sin", 15, 9, nil},
{"ksin", 16, 2, nil},
{"nuksin", 17, 1, nil},
{"daks", -1, 5, nil},
{"taks", -1, 5, nil}
]
@a_10 [
{"gi", -1, 1, nil},
{"ki", -1, 2, nil}
]
@a_11 [
{"joob", -1, 1, nil},
{"jood", -1, 1, nil},
{"joodakse", 1, 3, nil},
{"jooma", -1, 3, nil},
{"joomata", 3, 3, nil},
{"joome", -1, 1, nil},
{"joon", -1, 1, nil},
{"joote", -1, 1, nil},
{"joovad", -1, 1, nil},
{"juua", -1, 3, nil},
{"juuakse", 9, 3, nil},
{"jäi", -1, 38, nil},
{"jäid", 11, 38, nil},
{"jäime", 11, 38, nil},
{"jäin", 11, 38, nil},
{"jäite", 11, 38, nil},
{"jääb", -1, 36, nil},
{"jääd", -1, 36, nil},
{"jääda", 17, 39, nil},
{"jäädakse", 18, 39, nil},
{"jäädi", 17, 39, nil},
{"jääks", -1, 37, nil},
{"jääksid", 21, 37, nil},
{"jääksime", 21, 37, nil},
{"jääksin", 21, 37, nil},
{"jääksite", 21, 37, nil},
{"jääma", -1, 39, nil},
{"jäämata", 26, 39, nil},
{"jääme", -1, 36, nil},
{"jään", -1, 36, nil},
{"jääte", -1, 36, nil},
{"jäävad", -1, 36, nil},
{"jõi", -1, 2, nil},
{"jõid", 32, 2, nil},
{"jõime", 32, 2, nil},
{"jõin", 32, 2, nil},
{"jõite", 32, 2, nil},
{"keeb", -1, 12, nil},
{"keed", -1, 12, nil},
{"keedakse", 38, 14, nil},
{"keeks", -1, 13, nil},
{"keeksid", 40, 13, nil},
{"keeksime", 40, 13, nil},
{"keeksin", 40, 13, nil},
{"keeksite", 40, 13, nil},
{"keema", -1, 14, nil},
{"keemata", 45, 14, nil},
{"keeme", -1, 12, nil},
{"keen", -1, 12, nil},
{"kees", -1, 12, nil},
{"keeta", -1, 14, nil},
{"keete", -1, 12, nil},
{"keevad", -1, 12, nil},
{"käia", -1, 24, nil},
{"käiakse", 53, 24, nil},
{"käib", -1, 22, nil},
{"käid", -1, 22, nil},
{"käidi", 56, 24, nil},
{"käiks", -1, 23, nil},
{"käiksid", 58, 23, nil},
{"käiksime", 58, 23, nil},
{"käiksin", 58, 23, nil},
{"käiksite", 58, 23, nil},
{"käima", -1, 24, nil},
{"käimata", 63, 24, nil},
{"käime", -1, 22, nil},
{"käin", -1, 22, nil},
{"käis", -1, 22, nil},
{"käite", -1, 22, nil},
{"käivad", -1, 22, nil},
{"laob", -1, 47, nil},
{"laod", -1, 47, nil},
{"laoks", -1, 48, nil},
{"laoksid", 72, 48, nil},
{"laoksime", 72, 48, nil},
{"laoksin", 72, 48, nil},
{"laoksite", 72, 48, nil},
{"laome", -1, 47, nil},
{"laon", -1, 47, nil},
{"laote", -1, 47, nil},
{"laovad", -1, 47, nil},
{"loeb", -1, 43, nil},
{"loed", -1, 43, nil},
{"loeks", -1, 44, nil},
{"loeksid", 83, 44, nil},
{"loeksime", 83, 44, nil},
{"loeksin", 83, 44, nil},
{"loeksite", 83, 44, nil},
{"loeme", -1, 43, nil},
{"loen", -1, 43, nil},
{"loete", -1, 43, nil},
{"loevad", -1, 43, nil},
{"loob", -1, 19, nil},
{"lood", -1, 19, nil},
{"loodi", 93, 21, nil},
{"looks", -1, 20, nil},
{"looksid", 95, 20, nil},
{"looksime", 95, 20, nil},
{"looksin", 95, 20, nil},
{"looksite", 95, 20, nil},
{"looma", -1, 21, nil},
{"loomata", 100, 21, nil},
{"loome", -1, 19, nil},
{"loon", -1, 19, nil},
{"loote", -1, 19, nil},
{"loovad", -1, 19, nil},
{"luua", -1, 21, nil},
{"luuakse", 106, 21, nil},
{"lõi", -1, 18, nil},
{"lõid", 108, 18, nil},
{"lõime", 108, 18, nil},
{"lõin", 108, 18, nil},
{"lõite", 108, 18, nil},
{"lööb", -1, 15, nil},
{"lööd", -1, 15, nil},
{"löödakse", 114, 17, nil},
{"löödi", 114, 17, nil},
{"lööks", -1, 16, nil},
{"lööksid", 117, 16, nil},
{"lööksime", 117, 16, nil},
{"lööksin", 117, 16, nil},
{"lööksite", 117, 16, nil},
{"lööma", -1, 17, nil},
{"löömata", 122, 17, nil},
{"lööme", -1, 15, nil},
{"löön", -1, 15, nil},
{"lööte", -1, 15, nil},
{"löövad", -1, 15, nil},
{"lüüa", -1, 17, nil},
{"lüüakse", 128, 17, nil},
{"müüa", -1, 42, nil},
{"müüakse", 130, 42, nil},
{"müüb", -1, 40, nil},
{"müüd", -1, 40, nil},
{"müüdi", 133, 42, nil},
{"müüks", -1, 41, nil},
{"müüksid", 135, 41, nil},
{"müüksime", 135, 41, nil},
{"müüksin", 135, 41, nil},
{"müüksite", 135, 41, nil},
{"müüma", -1, 42, nil},
{"müümata", 140, 42, nil},
{"müüme", -1, 40, nil},
{"müün", -1, 40, nil},
{"müüs", -1, 40, nil},
{"müüte", -1, 40, nil},
{"müüvad", -1, 40, nil},
{"näeb", -1, 52, nil},
{"näed", -1, 52, nil},
{"näeks", -1, 53, nil},
{"näeksid", 149, 53, nil},
{"näeksime", 149, 53, nil},
{"näeksin", 149, 53, nil},
{"näeksite", 149, 53, nil},
{"näeme", -1, 52, nil},
{"näen", -1, 52, nil},
{"näete", -1, 52, nil},
{"näevad", -1, 52, nil},
{"nägema", -1, 54, nil},
{"nägemata", 158, 54, nil},
{"näha", -1, 54, nil},
{"nähakse", 160, 54, nil},
{"nähti", -1, 54, nil},
{"põeb", -1, 45, nil},
{"põed", -1, 45, nil},
{"põeks", -1, 46, nil},
{"põeksid", 165, 46, nil},
{"põeksime", 165, 46, nil},
{"põeksin", 165, 46, nil},
{"põeksite", 165, 46, nil},
{"põeme", -1, 45, nil},
{"põen", -1, 45, nil},
{"põete", -1, 45, nil},
{"põevad", -1, 45, nil},
{"saab", -1, 4, nil},
{"saad", -1, 4, nil},
{"saada", 175, 7, nil},
{"saadakse", 176, 7, nil},
{"saadi", 175, 7, nil},
{"saaks", -1, 5, nil},
{"saaksid", 179, 5, nil},
{"saaksime", 179, 5, nil},
{"saaksin", 179, 5, nil},
{"saaksite", 179, 5, nil},
{"saama", -1, 7, nil},
{"saamata", 184, 7, nil},
{"saame", -1, 4, nil},
{"saan", -1, 4, nil},
{"saate", -1, 4, nil},
{"saavad", -1, 4, nil},
{"sai", -1, 6, nil},
{"said", 190, 6, nil},
{"saime", 190, 6, nil},
{"sain", 190, 6, nil},
{"saite", 190, 6, nil},
{"sõi", -1, 27, nil},
{"sõid", 195, 27, nil},
{"sõime", 195, 27, nil},
{"sõin", 195, 27, nil},
{"sõite", 195, 27, nil},
{"sööb", -1, 25, nil},
{"sööd", -1, 25, nil},
{"söödakse", 201, 28, nil},
{"söödi", 201, 28, nil},
{"sööks", -1, 26, nil},
{"sööksid", 204, 26, nil},
{"sööksime", 204, 26, nil},
{"sööksin", 204, 26, nil},
{"sööksite", 204, 26, nil},
{"sööma", -1, 28, nil},
{"söömata", 209, 28, nil},
{"sööme", -1, 25, nil},
{"söön", -1, 25, nil},
{"sööte", -1, 25, nil},
{"söövad", -1, 25, nil},
{"süüa", -1, 28, nil},
{"süüakse", 215, 28, nil},
{"teeb", -1, 50, nil},
{"teed", -1, 50, nil},
{"teeks", -1, 49, nil},
{"teeksid", 219, 49, nil},
{"teeksime", 219, 49, nil},
{"teeksin", 219, 49, nil},
{"teeksite", 219, 49, nil},
{"teeme", -1, 50, nil},
{"teen", -1, 50, nil},
{"teete", -1, 50, nil},
{"teevad", -1, 50, nil},
{"tegema", -1, 51, nil},
{"tegemata", 228, 51, nil},
{"teha", -1, 51, nil},
{"tehakse", 230, 51, nil},
{"tehti", -1, 51, nil},
{"toob", -1, 29, nil},
{"tood", -1, 29, nil},
{"toodi", 234, 32, nil},
{"tooks", -1, 30, nil},
{"tooksid", 236, 30, nil},
{"tooksime", 236, 30, nil},
{"tooksin", 236, 30, nil},
{"tooksite", 236, 30, nil},
{"tooma", -1, 32, nil},
{"toomata", 241, 32, nil},
{"toome", -1, 29, nil},
{"toon", -1, 29, nil},
{"toote", -1, 29, nil},
{"toovad", -1, 29, nil},
{"tuua", -1, 32, nil},
{"tuuakse", 247, 32, nil},
{"tõi", -1, 31, nil},
{"tõid", 249, 31, nil},
{"tõime", 249, 31, nil},
{"tõin", 249, 31, nil},
{"tõite", 249, 31, nil},
{"viia", -1, 11, nil},
{"viiakse", 254, 11, nil},
{"viib", -1, 8, nil},
{"viid", -1, 8, nil},
{"viidi", 257, 11, nil},
{"viiks", -1, 9, nil},
{"viiksid", 259, 9, nil},
{"viiksime", 259, 9, nil},
{"viiksin", 259, 9, nil},
{"viiksite", 259, 9, nil},
{"viima", -1, 11, nil},
{"viimata", 264, 11, nil},
{"viime", -1, 8, nil},
{"viin", -1, 8, nil},
{"viisime", -1, 10, nil},
{"viisin", -1, 10, nil},
{"viisite", -1, 10, nil},
{"viite", -1, 8, nil},
{"viivad", -1, 8, nil},
{"võib", -1, 33, nil},
{"võid", -1, 33, nil},
{"võida", 274, 35, nil},
{"võidakse", 275, 35, nil},
{"võidi", 274, 35, nil},
{"võiks", -1, 34, nil},
{"võiksid", 278, 34, nil},
{"võiksime", 278, 34, nil},
{"võiksin", 278, 34, nil},
{"võiksite", 278, 34, nil},
{"võima", -1, 35, nil},
{"võimata", 283, 35, nil},
{"võime", -1, 33, nil},
{"võin", -1, 33, nil},
{"võis", -1, 33, nil},
{"võite", -1, 33, nil},
{"võivad", -1, 33, 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}}
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 next_codepoint_b(%Runtime{cursor: c, limit_backward: lb, current: cur} = state) do
case Runtime.codepoint_before(cur, c, lb) do
{_cp, size} -> {:ok, %{state | cursor: c - size}}
:error -> {:fail, state}
end
end
defp r_substantive(%Runtime{} = state) do
case (fn state ->
{:ok, snowball_do_b(state, fn state ->
r_special_noun_endings(state)
end)}
end).(state) do
{:ok, state} ->
case (fn state ->
{:ok, snowball_do_b(state, fn state ->
r_case_ending(state)
end)}
end).(state) do
{:ok, state} ->
case (fn state ->
{:ok, snowball_do_b(state, fn state ->
r_plural_three_first_cases(state)
end)}
end).(state) do
{:ok, state} ->
case (fn state ->
{:ok, snowball_do_b(state, fn state ->
r_degrees(state)
end)}
end).(state) do
{:ok, state} ->
case (fn state ->
{:ok, snowball_do_b(state, fn state ->
r_i_plural(state)
end)}
end).(state) do
{:ok, state} ->
{:ok, snowball_do_b(state, fn state ->
r_nu(state)
end)}
end
end
end
end
end
end
defp r_degrees(%Runtime{} = state) do
(fn ->
old_limit = state.limit_backward
case (fn state ->
(fn ->
target = state.vars[:p1]
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} ->
state = %{state | ket: state.cursor, limit_backward: limit_state.cursor}
case Runtime.find_among_b(state, @a_0) do
:fail -> {:fail, %{state | limit_backward: old_limit}}
{%Runtime{} = s, result} ->
state = %{s | bra: s.cursor, limit_backward: old_limit}
case result do
1 ->
case (fn state ->
lift(state, Runtime.in_grouping_b(state, @g_RV))
end).(state) do
{:ok, state} ->
{:ok, Runtime.slice_del(state)}
r -> r
end
2 ->
{:ok, Runtime.slice_del(state)}
3 ->
case (fn state ->
lift(state, Runtime.in_grouping_b(state, @g_RV))
end).(state) do
{:ok, state} ->
{:ok, Runtime.slice_del(state)}
r -> r
end
_ -> {:ok, state}
end
end
end
end).()
end
defp r_undouble_kpt(%Runtime{} = state) do
case (fn state ->
lift(state, Runtime.in_grouping_b(state, @g_V1))
end).(state) do
{:ok, state} ->
case (fn state ->
if state.vars[:p1] <= state.cursor, do: {:ok, state}, else: {:fail, state}
end).(state) do
{:ok, 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 ->
{:ok, Runtime.slice_from(state, "k")}
2 ->
{:ok, Runtime.slice_from(state, "p")}
3 ->
{:ok, Runtime.slice_from(state, "t")}
_ -> {:ok, state}
end
end
end).()
r -> r
end
r -> r
end
end
defp r_nu(%Runtime{} = state) do
case (fn state ->
(fn ->
old_limit = state.limit_backward
case (fn state ->
(fn ->
target = state.vars[:p1]
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} ->
state = %{state | ket: state.cursor, limit_backward: limit_state.cursor}
case Runtime.find_among_b(state, @a_2) do
:fail -> {:fail, %{state | limit_backward: old_limit}}
{%Runtime{} = s, _result} ->
state = %{s | bra: s.cursor, limit_backward: old_limit}
{:ok, state}
end
end
end).()
end).(state) do
{:ok, state} ->
{:ok, Runtime.slice_del(state)}
r -> r
end
end
defp r_plural_three_first_cases(%Runtime{} = state) do
(fn ->
old_limit = state.limit_backward
case (fn state ->
(fn ->
target = state.vars[:p1]
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} ->
state = %{state | ket: state.cursor, limit_backward: limit_state.cursor}
case Runtime.find_among_b(state, @a_4) do
:fail -> {:fail, %{state | limit_backward: old_limit}}
{%Runtime{} = s, result} ->
state = %{s | bra: s.cursor, limit_backward: old_limit}
case result do
1 ->
{:ok, Runtime.slice_from(state, "iku")}
2 ->
{:ok, Runtime.slice_from(state, "iku")}
3 ->
{:ok, Runtime.slice_from(state, "iku")}
4 ->
case (fn state ->
(fn state ->
saved_c = state.cursor
case (fn state ->
r_LONGV(state)
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_del(state)}
r -> r
end
5 ->
snowball_or(state,
fn state ->
case (fn state ->
snowball_test_b(state, fn state ->
(fn ->
n = 4
Enum.reduce_while(1..max(n, 0)//1, {:ok, state}, fn _, {:ok, s} ->
case next_codepoint_b(s) do
{:ok, s2} -> {:cont, {:ok, s2}}
{:fail, _} -> {:halt, {:fail, state}}
end
end)
end).()
end)
end).(state) do
{:ok, state} ->
(fn ->
case Runtime.find_among_b(state, @a_3) do
:fail -> {:fail, state}
{%Runtime{} = s, result} ->
state = s
case result do
1 ->
{:ok, Runtime.slice_from(state, "e")}
2 ->
{:ok, Runtime.slice_del(state)}
_ -> {:ok, s}
end
end
end).()
r -> r
end
end,
fn state ->
{:ok, Runtime.slice_from(state, "t")}
end)
6 ->
case (fn state ->
snowball_or(state,
fn state ->
lift(state, Runtime.in_grouping_b(state, @g_RV))
end,
fn state ->
r_LONGV(state)
end)
end).(state) do
{:ok, state} ->
{:ok, Runtime.slice_del(state)}
r -> r
end
7 ->
case (fn state ->
snowball_or(state,
fn state ->
lift(state, Runtime.in_grouping_b(state, @g_RV))
end,
fn state ->
r_LONGV(state)
end)
end).(state) do
{:ok, state} ->
{:ok, Runtime.slice_del(state)}
r -> r
end
_ -> {:ok, state}
end
end
end
end).()
end
defp r_case_ending(%Runtime{} = state) do
case (fn state ->
(fn ->
old_limit = state.limit_backward
case (fn state ->
(fn ->
target = state.vars[:p1]
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} ->
state = %{state | ket: state.cursor, limit_backward: limit_state.cursor}
case Runtime.find_among_b(state, @a_5) do
:fail -> {:fail, %{state | limit_backward: old_limit}}
{%Runtime{} = s, result} ->
state = %{s | bra: s.cursor, limit_backward: old_limit}
case result do
1 ->
snowball_or(state,
fn state ->
lift(state, Runtime.in_grouping_b(state, @g_RV))
end,
fn state ->
r_LONGV(state)
end)
2 ->
snowball_or(state,
fn state ->
lift(state, Runtime.in_grouping_b(state, @g_RV))
end,
fn state ->
r_LONGV(state)
end)
3 ->
snowball_or(state,
fn state ->
lift(state, Runtime.in_grouping_b(state, @g_RV))
end,
fn state ->
r_LONGV(state)
end)
4 ->
snowball_or(state,
fn state ->
lift(state, Runtime.in_grouping_b(state, @g_RV))
end,
fn state ->
r_LONGV(state)
end)
5 ->
snowball_or(state,
fn state ->
lift(state, Runtime.in_grouping_b(state, @g_RV))
end,
fn state ->
r_LONGV(state)
end)
6 ->
snowball_or(state,
fn state ->
lift(state, Runtime.in_grouping_b(state, @g_RV))
end,
fn state ->
r_LONGV(state)
end)
7 ->
snowball_or(state,
fn state ->
lift(state, Runtime.in_grouping_b(state, @g_RV))
end,
fn state ->
r_LONGV(state)
end)
8 ->
snowball_test_b(state, fn state ->
(fn ->
n = 4
Enum.reduce_while(1..max(n, 0)//1, {:ok, state}, fn _, {:ok, s} ->
case next_codepoint_b(s) do
{:ok, s2} -> {:cont, {:ok, s2}}
{:fail, _} -> {:halt, {:fail, state}}
end
end)
end).()
end)
9 ->
snowball_or(state,
fn state ->
lift(state, Runtime.in_grouping_b(state, @g_RV))
end,
fn state ->
r_LONGV(state)
end)
10 ->
snowball_or(state,
fn state ->
lift(state, Runtime.in_grouping_b(state, @g_RV))
end,
fn state ->
r_LONGV(state)
end)
_ -> {:ok, state}
end
end
end
end).()
end).(state) do
{:ok, state} ->
{:ok, Runtime.slice_del(state)}
r -> r
end
end
defp r_special_noun_endings(%Runtime{} = state) do
(fn ->
old_limit = state.limit_backward
case (fn state ->
(fn ->
target = state.vars[:p1]
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} ->
state = %{state | ket: state.cursor, limit_backward: limit_state.cursor}
case Runtime.find_among_b(state, @a_6) do
:fail -> {:fail, %{state | limit_backward: old_limit}}
{%Runtime{} = s, result} ->
state = %{s | bra: s.cursor, limit_backward: old_limit}
case result do
1 ->
{:ok, Runtime.slice_from(state, "lase")}
2 ->
{:ok, Runtime.slice_from(state, "lase")}
3 ->
{:ok, Runtime.slice_from(state, "lase")}
4 ->
{:ok, Runtime.slice_from(state, "lase")}
5 ->
{:ok, Runtime.slice_from(state, "mise")}
6 ->
{:ok, Runtime.slice_from(state, "mise")}
7 ->
{:ok, Runtime.slice_from(state, "mise")}
8 ->
{:ok, Runtime.slice_from(state, "mise")}
9 ->
{:ok, Runtime.slice_from(state, "lise")}
10 ->
{:ok, Runtime.slice_from(state, "lise")}
11 ->
{:ok, Runtime.slice_from(state, "lise")}
12 ->
{:ok, Runtime.slice_from(state, "lise")}
_ -> {:ok, state}
end
end
end
end).()
end
defp r_i_plural(%Runtime{} = state) do
case (fn state ->
(fn ->
old_limit = state.limit_backward
case (fn state ->
(fn ->
target = state.vars[:p1]
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} ->
state = %{state | ket: state.cursor, limit_backward: limit_state.cursor}
case Runtime.find_among_b(state, @a_7) do
:fail -> {:fail, %{state | limit_backward: old_limit}}
{%Runtime{} = s, result} ->
state = %{s | bra: s.cursor, limit_backward: old_limit}
case result do
1 ->
lift(state, Runtime.in_grouping_b(state, @g_RV))
_ -> {:ok, state}
end
end
end
end).()
end).(state) do
{:ok, state} ->
{:ok, Runtime.slice_del(state)}
r -> r
end
end
defp r_LONGV(%Runtime{} = state) do
(fn ->
case Runtime.find_among_b(state, @a_8) do
:fail -> {:fail, state}
{%Runtime{} = s, _} -> {:ok, s}
end
end).()
end
defp r_verb(%Runtime{} = state) do
(fn ->
old_limit = state.limit_backward
case (fn state ->
(fn ->
target = state.vars[:p1]
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} ->
state = %{state | ket: state.cursor, limit_backward: limit_state.cursor}
case Runtime.find_among_b(state, @a_9) do
:fail -> {:fail, %{state | limit_backward: old_limit}}
{%Runtime{} = s, result} ->
state = %{s | bra: s.cursor, limit_backward: old_limit}
case result do
1 ->
{:ok, Runtime.slice_del(state)}
2 ->
{:ok, Runtime.slice_del(state)}
3 ->
{:ok, Runtime.slice_del(state)}
4 ->
{:ok, Runtime.slice_del(state)}
5 ->
{:ok, Runtime.slice_del(state)}
6 ->
{:ok, Runtime.slice_from(state, "a")}
7 ->
{:ok, Runtime.slice_del(state)}
8 ->
{:ok, Runtime.slice_del(state)}
9 ->
{:ok, Runtime.slice_del(state)}
10 ->
case (fn state ->
lift(state, Runtime.in_grouping_b(state, @g_V1))
end).(state) do
{:ok, state} ->
{:ok, Runtime.slice_del(state)}
r -> r
end
11 ->
case (fn state ->
lift(state, Runtime.in_grouping_b(state, @g_V1))
end).(state) do
{:ok, state} ->
{:ok, Runtime.slice_del(state)}
r -> r
end
12 ->
case (fn state ->
lift(state, Runtime.in_grouping_b(state, @g_V1))
end).(state) do
{:ok, state} ->
{:ok, Runtime.slice_del(state)}
r -> r
end
13 ->
case (fn state ->
lift(state, Runtime.in_grouping_b(state, @g_V1))
end).(state) do
{:ok, state} ->
{:ok, Runtime.slice_del(state)}
r -> r
end
_ -> {:ok, state}
end
end
end
end).()
end
defp r_emphasis(%Runtime{} = state) do
(fn ->
old_limit = state.limit_backward
case (fn state ->
(fn ->
target = state.vars[:p1]
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} ->
state = %{state | ket: state.cursor, limit_backward: limit_state.cursor}
case Runtime.find_among_b(state, @a_10) do
:fail -> {:fail, %{state | limit_backward: old_limit}}
{%Runtime{} = s, result} ->
state = %{s | bra: s.cursor, limit_backward: old_limit}
case (fn state ->
snowball_test_b(state, fn state ->
(fn ->
n = 4
Enum.reduce_while(1..max(n, 0)//1, {:ok, state}, fn _, {:ok, s} ->
case next_codepoint_b(s) do
{:ok, s2} -> {:cont, {:ok, s2}}
{:fail, _} -> {:halt, {:fail, state}}
end
end)
end).()
end)
end).(state) do
{:ok, state} ->
case result do
1 ->
case (fn state ->
case (fn state ->
snowball_test_b(state, fn state ->
lift(state, Runtime.in_grouping_b(state, @g_GI))
end)
end).(state) do
{:ok, state} ->
(fn state ->
saved_c = state.cursor
case (fn state ->
r_LONGV(state)
end).(state) do
{:ok, s} -> {:fail, %{s | cursor: saved_c}}
{:fail, s} -> {:ok, %{s | cursor: saved_c}}
end
end).(state)
r -> r
end
end).(state) do
{:ok, state} ->
{:ok, Runtime.slice_del(state)}
r -> r
end
2 ->
case (fn state ->
lift(state, Runtime.in_grouping_b(state, @g_KI))
end).(state) do
{:ok, state} ->
{:ok, Runtime.slice_del(state)}
r -> r
end
_ -> {:ok, state}
end
r -> r
end
end
end
end).()
end
defp r_mark_regions(%Runtime{} = state) do
case (fn state ->
{:ok, put_in(state.vars[:p1], state.limit)}
end).(state) do
{:ok, state} ->
case (fn state ->
case Runtime.go_out_grouping(state, @g_V1) 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_V1) do
:fail -> {:fail, state}
%Runtime{} = s -> next_codepoint(s)
end
end).(state) do
{:ok, state} ->
{:ok, put_in(state.vars[:p1], state.cursor)}
r -> r
end
r -> r
end
end
end
defp r_verb_exceptions(%Runtime{} = state) do
(fn ->
state = %{state | bra: state.cursor}
case Runtime.find_among(state, @a_11) do
:fail -> {:fail, state}
{%Runtime{} = s, result} ->
state = %{s | ket: s.cursor}
case (fn state ->
if state.cursor >= state.limit, do: {:ok, state}, else: {:fail, state}
end).(state) do
{:ok, state} ->
case result do
1 ->
{:ok, Runtime.slice_from(state, "joo")}
2 ->
{:ok, Runtime.slice_from(state, "joo")}
3 ->
{:ok, Runtime.slice_from(state, "joo")}
4 ->
{:ok, Runtime.slice_from(state, "saa")}
5 ->
{:ok, Runtime.slice_from(state, "saa")}
6 ->
{:ok, Runtime.slice_from(state, "saa")}
7 ->
{:ok, Runtime.slice_from(state, "saa")}
8 ->
{:ok, Runtime.slice_from(state, "viima")}
9 ->
{:ok, Runtime.slice_from(state, "viima")}
10 ->
{:ok, Runtime.slice_from(state, "viima")}
11 ->
{:ok, Runtime.slice_from(state, "viima")}
12 ->
{:ok, Runtime.slice_from(state, "keesi")}
13 ->
{:ok, Runtime.slice_from(state, "keesi")}
14 ->
{:ok, Runtime.slice_from(state, "keesi")}
15 ->
{:ok, Runtime.slice_from(state, "löö")}
16 ->
{:ok, Runtime.slice_from(state, "löö")}
17 ->
{:ok, Runtime.slice_from(state, "löö")}
18 ->
{:ok, Runtime.slice_from(state, "lõi")}
19 ->
{:ok, Runtime.slice_from(state, "loo")}
20 ->
{:ok, Runtime.slice_from(state, "loo")}
21 ->
{:ok, Runtime.slice_from(state, "loo")}
22 ->
{:ok, Runtime.slice_from(state, "käisi")}
23 ->
{:ok, Runtime.slice_from(state, "käisi")}
24 ->
{:ok, Runtime.slice_from(state, "käisi")}
25 ->
{:ok, Runtime.slice_from(state, "söö")}
26 ->
{:ok, Runtime.slice_from(state, "söö")}
27 ->
{:ok, Runtime.slice_from(state, "söö")}
28 ->
{:ok, Runtime.slice_from(state, "söö")}
29 ->
{:ok, Runtime.slice_from(state, "too")}
30 ->
{:ok, Runtime.slice_from(state, "too")}
31 ->
{:ok, Runtime.slice_from(state, "too")}
32 ->
{:ok, Runtime.slice_from(state, "too")}
33 ->
{:ok, Runtime.slice_from(state, "võisi")}
34 ->
{:ok, Runtime.slice_from(state, "võisi")}
35 ->
{:ok, Runtime.slice_from(state, "võisi")}
36 ->
{:ok, Runtime.slice_from(state, "jääma")}
37 ->
{:ok, Runtime.slice_from(state, "jääma")}
38 ->
{:ok, Runtime.slice_from(state, "jääma")}
39 ->
{:ok, Runtime.slice_from(state, "jääma")}
40 ->
{:ok, Runtime.slice_from(state, "müüsi")}
41 ->
{:ok, Runtime.slice_from(state, "müüsi")}
42 ->
{:ok, Runtime.slice_from(state, "müüsi")}
43 ->
{:ok, Runtime.slice_from(state, "luge")}
44 ->
{:ok, Runtime.slice_from(state, "luge")}
45 ->
{:ok, Runtime.slice_from(state, "põde")}
46 ->
{:ok, Runtime.slice_from(state, "põde")}
47 ->
{:ok, Runtime.slice_from(state, "ladu")}
48 ->
{:ok, Runtime.slice_from(state, "ladu")}
49 ->
{:ok, Runtime.slice_from(state, "tegi")}
50 ->
{:ok, Runtime.slice_from(state, "tegi")}
51 ->
{:ok, Runtime.slice_from(state, "tegi")}
52 ->
{:ok, Runtime.slice_from(state, "nägi")}
53 ->
{:ok, Runtime.slice_from(state, "nägi")}
54 ->
{:ok, Runtime.slice_from(state, "nägi")}
_ -> {:ok, state}
end
r -> r
end
end
end).()
end
defp r_stem(%Runtime{} = state) do
case (fn state ->
(fn state ->
saved_c = state.cursor
case (fn state ->
r_verb_exceptions(state)
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} ->
case (fn state ->
{:ok, snowball_do_f(state, fn state ->
r_mark_regions(state)
end)}
end).(state) do
{:ok, 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_emphasis(state)
end)}
end).(state) do
{:ok, state} ->
case (fn state ->
{:ok, snowball_do_b(state, fn state ->
snowball_or(state,
fn state ->
r_verb(state)
end,
fn state ->
r_substantive(state)
end)
end)}
end).(state) do
{:ok, state} ->
{:ok, snowball_do_b(state, fn state ->
r_undouble_kpt(state)
end)}
end
end
end).(state)
{tag, %{s | cursor: old_cursor, limit_backward: old_lb}}
end).(state)
end
r -> r
end
end
end