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/esperanto.ex
# Generated by Snowball.Generator — do not edit by hand.
defmodule Text.Stemmer.Stemmers.Esperanto do
@moduledoc """
Snowball stemmer for esperanto.
Generated from the canonical Snowball algorithm source.
"""
alias Snowball.Runtime
alias Snowball.Grouping
# Groupings
@g_aou Grouping.from_string("aou")
@g_digit Grouping.from_string("0123456789")
@g_vowel Grouping.from_string("aeiou")
# Among tables
@a_0 [
{"a", -1, -1, nil},
{"e", -1, -1, nil},
{"i", -1, -1, nil},
{"j", -1, 1, nil},
{"aj", 3, -1, nil},
{"oj", 3, -1, nil},
{"n", -1, 1, nil},
{"an", 6, -1, nil},
{"en", 6, -1, nil},
{"jn", 6, 1, nil},
{"ajn", 9, -1, nil},
{"ojn", 9, -1, nil},
{"on", 6, -1, nil},
{"o", -1, -1, nil},
{"as", -1, -1, nil},
{"is", -1, -1, nil},
{"os", -1, -1, nil},
{"us", -1, -1, nil},
{"u", -1, -1, nil}
]
@a_1 [
{"k", -1, -1, nil},
{"kelk", 0, -1, nil},
{"nen", -1, -1, nil},
{"t", -1, -1, nil},
{"mult", 3, -1, nil},
{"samt", 3, -1, nil},
{"ĉ", -1, -1, nil}
]
@a_2 [
{"tri", -1, -1, nil},
{"du", -1, -1, nil},
{"unu", -1, -1, nil}
]
@a_3 [
{"dek", -1, -1, nil},
{"cent", -1, -1, nil}
]
@a_4 [
{"aha", -1, -1, nil},
{"haha", 0, -1, nil},
{"haleluja", -1, -1, nil},
{"hola", -1, -1, nil},
{"hosana", -1, -1, nil},
{"maltra", -1, -1, nil},
{"hura", -1, -1, nil},
{"ĥaĥa", -1, -1, nil},
{"ekde", -1, -1, nil},
{"elde", -1, -1, nil},
{"disde", -1, -1, nil},
{"ehe", -1, -1, nil},
{"maltre", -1, -1, nil},
{"dirlididi", -1, -1, nil},
{"malpli", -1, -1, nil},
{"malĉi", -1, -1, nil},
{"malkaj", -1, -1, nil},
{"amen", -1, -1, nil},
{"tamen", 17, -1, nil},
{"oho", -1, -1, nil},
{"maltro", -1, -1, nil},
{"minus", -1, -1, nil},
{"uhu", -1, -1, nil},
{"muu", -1, -1, nil}
]
@a_5 [
{"aliu", -1, -1, nil},
{"unu", -1, -1, nil}
]
@a_6 [
{"amb", -1, -1, nil},
{"bald", -1, -1, nil},
{"malbald", 1, -1, nil},
{"morg", -1, -1, nil},
{"postmorg", 3, -1, nil},
{"adi", -1, -1, nil},
{"hodi", -1, -1, nil},
{"ank", -1, -1, nil},
{"ĉirk", -1, -1, nil},
{"tutĉirk", 8, -1, nil},
{"presk", -1, -1, nil},
{"almen", -1, -1, nil},
{"apen", -1, -1, nil},
{"hier", -1, -1, nil},
{"antaŭhier", 13, -1, nil},
{"malgr", -1, -1, nil},
{"ankor", -1, -1, nil},
{"kontr", -1, -1, nil},
{"anstat", -1, -1, nil},
{"kvaz", -1, -1, nil}
]
@a_7 [
{"ci", -1, -1, nil},
{"gi", -1, -1, nil},
{"hi", -1, -1, nil},
{"li", -1, -1, nil},
{"ili", 3, -1, nil},
{"ŝli", 3, -1, nil},
{"mi", -1, -1, nil},
{"ni", -1, -1, nil},
{"oni", 7, -1, nil},
{"ri", -1, -1, nil},
{"si", -1, -1, nil},
{"vi", -1, -1, nil},
{"ivi", 11, -1, nil},
{"ĝi", -1, -1, nil},
{"ŝi", -1, -1, nil},
{"iŝi", 14, -1, nil},
{"malŝi", 14, -1, nil}
]
@a_8 [
{"", -1, 14, nil},
{"-", 0, 13, nil},
{"cx", 0, 1, nil},
{"gx", 0, 2, nil},
{"hx", 0, 3, nil},
{"jx", 0, 4, nil},
{"q", 0, 12, nil},
{"sx", 0, 5, nil},
{"ux", 0, 6, nil},
{"w", 0, 12, nil},
{"x", 0, 12, nil},
{"y", 0, 12, nil},
{"á", 0, 7, nil},
{"é", 0, 8, nil},
{"í", 0, 9, nil},
{"ó", 0, 10, nil},
{"ú", 0, 11, nil}
]
@a_9 [
{"as", -1, -1, nil},
{"i", -1, -1, nil},
{"is", 1, -1, nil},
{"os", -1, -1, nil},
{"u", -1, -1, nil},
{"us", 4, -1, 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: %{foreign: 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_f(state, fun) do
saved_c = state.cursor
case fun.(state) do
{:ok, s} -> {:ok, %{s | cursor: saved_c}}
{:fail, s} -> {:fail, %{s | cursor: saved_c}}
end
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_try(state, fun) do
rel = state.limit - state.cursor
case fun.(state) do
{:ok, s} -> s
{:fail, s} -> %{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_standard_suffix(%Runtime{} = state) do
case (fn state ->
{:ok, %{state | ket: state.cursor}}
end).(state) do
{:ok, state} ->
case (fn state ->
(fn ->
case Runtime.find_among_b(state, @a_0) do
:fail -> {:fail, state}
{%Runtime{} = s, result} ->
state = s
case result do
1 ->
snowball_test_b(state, fn state ->
snowball_or(state,
fn state ->
lift(state, Runtime.eq_s_b(state, "-"))
end,
fn state ->
lift(state, Runtime.in_grouping_b(state, @g_digit))
end)
end)
_ -> {:ok, s}
end
end
end).()
end).(state) do
{:ok, state} ->
case (fn state ->
{:ok, snowball_try(state, fn state ->
lift(state, Runtime.eq_s_b(state, "-"))
end)}
end).(state) do
{:ok, state} ->
case (fn state ->
{:ok, %{state | bra: state.cursor}}
end).(state) do
{:ok, state} ->
{:ok, Runtime.slice_del(state)}
end
end
r -> r
end
end
end
defp r_long_word(%Runtime{} = state) do
snowball_or(state,
fn state ->
snowball_or(state,
fn state ->
(fn ->
n = 2
Enum.reduce_while(1..max(n, 0)//1, {:ok, state}, fn _, {:ok, s} ->
case (fn state ->
case Runtime.go_out_grouping_b(state, @g_vowel) do
:fail -> {:fail, state}
%Runtime{} = s -> next_codepoint_b(s)
end
end).(s) do
{:ok, s2} -> {:cont, {:ok, s2}}
{:fail, s2} -> {:halt, {:fail, s2}}
end
end)
end).()
end,
fn state ->
case (fn state ->
(fn loop_fn ->
loop_fn.(loop_fn, state)
end).(fn loop_fn, state ->
v = state.cursor
case (fn state ->
lift(state, Runtime.eq_s_b(state, "-"))
end).(state) do
{:ok, s} -> {:ok, s}
{:fail, _} ->
case next_codepoint_b(%{state | cursor: v}) do
{:ok, s} -> loop_fn.(loop_fn, s)
{:fail, _} -> {:fail, state}
end
end
end)
end).(state) do
{:ok, state} ->
next_codepoint_b(state)
r -> r
end
end)
end,
fn state ->
case Runtime.go_out_grouping_b(state, @g_digit) do
:fail -> {:fail, state}
%Runtime{} = s -> next_codepoint_b(s)
end
end)
end
defp r_correlative(%Runtime{} = state) do
case (fn state ->
{:ok, %{state | ket: state.cursor}}
end).(state) do
{:ok, state} ->
case (fn state ->
{:ok, %{state | bra: state.cursor}}
end).(state) do
{:ok, state} ->
case (fn state ->
snowball_test_b(state, fn state ->
case (fn state ->
snowball_or(state,
fn state ->
case (fn state ->
{:ok, snowball_try(state, fn state ->
lift(state, Runtime.eq_s_b(state, "n"))
end)}
end).(state) do
{:ok, state} ->
case (fn state ->
{:ok, %{state | bra: state.cursor}}
end).(state) do
{:ok, state} ->
lift(state, Runtime.eq_s_b(state, "e"))
end
end
end,
fn state ->
case (fn state ->
{:ok, snowball_try(state, fn state ->
lift(state, Runtime.eq_s_b(state, "n"))
end)}
end).(state) do
{:ok, state} ->
case (fn state ->
{:ok, snowball_try(state, fn state ->
lift(state, Runtime.eq_s_b(state, "j"))
end)}
end).(state) do
{:ok, state} ->
case (fn state ->
{:ok, %{state | bra: state.cursor}}
end).(state) do
{:ok, state} ->
lift(state, Runtime.in_grouping_b(state, @g_aou))
end
end
end
end)
end).(state) do
{:ok, state} ->
case (fn state ->
lift(state, Runtime.eq_s_b(state, "i"))
end).(state) do
{:ok, state} ->
case (fn state ->
{:ok, snowball_try(state, fn state ->
(fn ->
case Runtime.find_among_b(state, @a_1) do
:fail -> {:fail, state}
{%Runtime{} = s, _} -> {:ok, s}
end
end).()
end)}
end).(state) do
{:ok, state} ->
snowball_or(state,
fn state ->
if state.cursor <= state.limit_backward, do: {:ok, state}, else: {:fail, state}
end,
fn state ->
lift(state, Runtime.eq_s_b(state, "-"))
end)
end
r -> r
end
r -> r
end
end)
end).(state) do
{:ok, state} ->
{:ok, Runtime.slice_del(state)}
r -> r
end
end
end
end
defp r_merged_numeral(%Runtime{} = state) do
case (fn state ->
(fn ->
case Runtime.find_among_b(state, @a_2) do
:fail -> {:fail, state}
{%Runtime{} = s, _} -> {:ok, s}
end
end).()
end).(state) do
{:ok, state} ->
(fn ->
case Runtime.find_among_b(state, @a_3) do
:fail -> {:fail, state}
{%Runtime{} = s, _} -> {:ok, s}
end
end).()
r -> r
end
end
defp r_uninflected(%Runtime{} = state) do
case (fn state ->
(fn ->
case Runtime.find_among_b(state, @a_4) do
:fail -> {:fail, state}
{%Runtime{} = s, _} -> {:ok, s}
end
end).()
end).(state) do
{:ok, state} ->
snowball_or(state,
fn state ->
if state.cursor <= state.limit_backward, do: {:ok, state}, else: {:fail, state}
end,
fn state ->
lift(state, Runtime.eq_s_b(state, "-"))
end)
r -> r
end
end
defp r_ujn_suffix(%Runtime{} = state) do
case (fn state ->
{:ok, %{state | ket: state.cursor}}
end).(state) do
{:ok, state} ->
case (fn state ->
{:ok, snowball_try(state, fn state ->
lift(state, Runtime.eq_s_b(state, "n"))
end)}
end).(state) do
{:ok, state} ->
case (fn state ->
{:ok, snowball_try(state, fn state ->
lift(state, Runtime.eq_s_b(state, "j"))
end)}
end).(state) do
{:ok, state} ->
case (fn state ->
{:ok, %{state | bra: state.cursor}}
end).(state) do
{:ok, state} ->
case (fn state ->
(fn ->
case Runtime.find_among_b(state, @a_5) do
:fail -> {:fail, state}
{%Runtime{} = s, _} -> {:ok, s}
end
end).()
end).(state) do
{:ok, state} ->
case (fn state ->
snowball_or(state,
fn state ->
if state.cursor <= state.limit_backward, do: {:ok, state}, else: {:fail, state}
end,
fn state ->
lift(state, Runtime.eq_s_b(state, "-"))
end)
end).(state) do
{:ok, state} ->
{:ok, Runtime.slice_del(state)}
r -> r
end
r -> r
end
end
end
end
end
end
defp r_final_apostrophe(%Runtime{} = state) do
case (fn state ->
{:ok, %{state | ket: state.cursor}}
end).(state) do
{:ok, state} ->
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} ->
snowball_or(state,
fn state ->
snowball_or(state,
fn state ->
snowball_or(state,
fn state ->
case (fn state ->
lift(state, Runtime.eq_s_b(state, "l"))
end).(state) do
{:ok, state} ->
case (fn state ->
if state.cursor <= state.limit_backward, do: {:ok, state}, else: {:fail, state}
end).(state) do
{:ok, state} ->
{:ok, Runtime.slice_from(state, "a")}
r -> r
end
r -> r
end
end,
fn state ->
case (fn state ->
lift(state, Runtime.eq_s_b(state, "un"))
end).(state) do
{:ok, state} ->
case (fn state ->
if state.cursor <= state.limit_backward, do: {:ok, state}, else: {:fail, state}
end).(state) do
{:ok, state} ->
{:ok, Runtime.slice_from(state, "u")}
r -> r
end
r -> r
end
end)
end,
fn state ->
case (fn state ->
(fn ->
case Runtime.find_among_b(state, @a_6) do
:fail -> {:fail, state}
{%Runtime{} = s, _} -> {:ok, s}
end
end).()
end).(state) do
{:ok, state} ->
case (fn state ->
snowball_or(state,
fn state ->
if state.cursor <= state.limit_backward, do: {:ok, state}, else: {:fail, state}
end,
fn state ->
lift(state, Runtime.eq_s_b(state, "-"))
end)
end).(state) do
{:ok, state} ->
{:ok, Runtime.slice_from(state, "aŭ")}
r -> r
end
r -> r
end
end)
end,
fn state ->
{:ok, Runtime.slice_from(state, "o")}
end)
end
r -> r
end
end
end
defp r_pronoun(%Runtime{} = state) do
case (fn state ->
{:ok, %{state | ket: state.cursor}}
end).(state) do
{:ok, state} ->
case (fn state ->
{:ok, snowball_try(state, fn state ->
lift(state, Runtime.eq_s_b(state, "n"))
end)}
end).(state) do
{:ok, state} ->
case (fn state ->
{:ok, %{state | bra: state.cursor}}
end).(state) do
{:ok, state} ->
case (fn state ->
(fn ->
case Runtime.find_among_b(state, @a_7) do
:fail -> {:fail, state}
{%Runtime{} = s, _} -> {:ok, s}
end
end).()
end).(state) do
{:ok, state} ->
case (fn state ->
snowball_or(state,
fn state ->
if state.cursor <= state.limit_backward, do: {:ok, state}, else: {:fail, state}
end,
fn state ->
lift(state, Runtime.eq_s_b(state, "-"))
end)
end).(state) do
{:ok, state} ->
{:ok, Runtime.slice_del(state)}
r -> r
end
r -> r
end
end
end
end
end
defp r_canonical_form(%Runtime{} = state) do
case (fn state ->
{:ok, put_in(state.vars[:foreign], 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 ->
(fn ->
state = %{state | bra: state.cursor}
case Runtime.find_among(state, @a_8) 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, "ĝ")}
3 ->
{:ok, Runtime.slice_from(state, "ĥ")}
4 ->
{:ok, Runtime.slice_from(state, "ĵ")}
5 ->
{:ok, Runtime.slice_from(state, "ŝ")}
6 ->
{:ok, Runtime.slice_from(state, "ŭ")}
7 ->
case (fn state ->
{:ok, Runtime.slice_from(state, "a")}
end).(state) do
{:ok, state} ->
{:ok, put_in(state.vars[:foreign], true)}
end
8 ->
case (fn state ->
{:ok, Runtime.slice_from(state, "e")}
end).(state) do
{:ok, state} ->
{:ok, put_in(state.vars[:foreign], true)}
end
9 ->
case (fn state ->
{:ok, Runtime.slice_from(state, "i")}
end).(state) do
{:ok, state} ->
{:ok, put_in(state.vars[:foreign], true)}
end
10 ->
case (fn state ->
{:ok, Runtime.slice_from(state, "o")}
end).(state) do
{:ok, state} ->
{:ok, put_in(state.vars[:foreign], true)}
end
11 ->
case (fn state ->
{:ok, Runtime.slice_from(state, "u")}
end).(state) do
{:ok, state} ->
{:ok, put_in(state.vars[:foreign], true)}
end
12 ->
{:ok, put_in(state.vars[:foreign], true)}
13 ->
{:ok, put_in(state.vars[:foreign], false)}
14 ->
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).(state) do
{:ok, state} ->
(fn state ->
saved_c = state.cursor
case (fn state ->
if state.vars[:foreign], do: {:ok, state}, else: {:fail, state}
end).(state) do
{:ok, s} -> {:fail, %{s | cursor: saved_c}}
{:fail, s} -> {:ok, %{s | cursor: saved_c}}
end
end).(state)
end
end
end
defp r_initial_apostrophe(%Runtime{} = state) do
case (fn state ->
{:ok, %{state | bra: state.cursor}}
end).(state) do
{:ok, state} ->
case (fn state ->
lift(state, Runtime.eq_s(state, "'"))
end).(state) do
{:ok, state} ->
case (fn state ->
{:ok, %{state | ket: state.cursor}}
end).(state) do
{:ok, state} ->
case (fn state ->
lift(state, Runtime.eq_s(state, "st"))
end).(state) do
{:ok, state} ->
case (fn state ->
(fn ->
case Runtime.find_among(state, @a_9) do
:fail -> {:fail, state}
{%Runtime{} = s, _} -> {:ok, s}
end
end).()
end).(state) do
{:ok, state} ->
case (fn state ->
if state.cursor >= state.limit, do: {:ok, state}, else: {:fail, state}
end).(state) do
{:ok, state} ->
{:ok, Runtime.slice_from(state, "e")}
r -> r
end
r -> r
end
r -> r
end
end
r -> r
end
end
end
defp r_stem(%Runtime{} = state) do
case (fn state ->
snowball_test_f(state, fn state ->
r_canonical_form(state)
end)
end).(state) do
{:ok, state} ->
case (fn state ->
{:ok, snowball_do_f(state, fn state ->
r_initial_apostrophe(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 ->
(fn state ->
saved_c = state.cursor
case (fn state ->
r_pronoun(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_b(state, fn state ->
r_final_apostrophe(state)
end)}
end).(state) do
{:ok, state} ->
case (fn state ->
(fn state ->
saved_c = state.cursor
case (fn state ->
r_correlative(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 ->
(fn state ->
saved_c = state.cursor
case (fn state ->
r_uninflected(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 ->
(fn state ->
saved_c = state.cursor
case (fn state ->
r_merged_numeral(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 ->
(fn state ->
saved_c = state.cursor
case (fn state ->
r_ujn_suffix(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 ->
snowball_test_b(state, fn state ->
r_long_word(state)
end)
end).(state) do
{:ok, state} ->
r_standard_suffix(state)
r -> r
end
r -> r
end
r -> r
end
r -> r
end
r -> r
end
end
r -> r
end
end).(state)
{tag, %{s | cursor: old_cursor, limit_backward: old_lb}}
end).(state)
end
r -> r
end
end
end