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/french.ex
# Generated by Snowball.Generator — do not edit by hand.
defmodule Text.Stemmer.Stemmers.French do
@moduledoc """
Snowball stemmer for french.
Generated from the canonical Snowball algorithm source.
"""
alias Snowball.Runtime
alias Snowball.Grouping
# Groupings
@g_elision_char Grouping.from_string("cdjlmnst")
@g_keep_with_s Grouping.from_string("aiouès")
@g_oux_ending Grouping.from_string("bhjlnp")
@g_v Grouping.from_string("aeiouyâàëéêèïîôûù")
# Among tables
@a_0 [
{"ell", -1, -1, nil},
{"eill", -1, -1, nil},
{"enn", -1, -1, nil},
{"onn", -1, -1, nil},
{"ett", -1, -1, nil}
]
@a_1 [
{"e", -1, 3, nil},
{"Ière", 0, 2, nil},
{"ière", 0, 2, nil},
{"ion", -1, 1, nil},
{"Ier", -1, 2, nil},
{"ier", -1, 2, nil}
]
@a_2 [
{"al", -1, 1, nil},
{"épl", -1, -1, nil},
{"auv", -1, -1, nil}
]
@a_3 [
{"a", -1, 3, nil},
{"era", 0, 2, nil},
{"aise", -1, 4, nil},
{"asse", -1, 3, nil},
{"ante", -1, 3, nil},
{"ée", -1, 2, nil},
{"ai", -1, 3, nil},
{"erai", 6, 2, nil},
{"er", -1, 2, nil},
{"as", -1, 3, nil},
{"eras", 9, 2, nil},
{"âmes", -1, 3, nil},
{"aises", -1, 4, nil},
{"asses", -1, 3, nil},
{"antes", -1, 3, nil},
{"âtes", -1, 3, nil},
{"ées", -1, 2, nil},
{"ais", -1, 4, nil},
{"eais", 17, 5, nil},
{"erais", 17, 2, nil},
{"ions", -1, 1, nil},
{"erions", 20, 2, nil},
{"assions", 20, 3, nil},
{"erons", -1, 2, nil},
{"ants", -1, 3, nil},
{"és", -1, 2, nil},
{"ait", -1, 3, nil},
{"erait", 26, 2, nil},
{"ant", -1, 3, nil},
{"aIent", -1, 3, nil},
{"eraIent", 29, 2, nil},
{"èrent", -1, 2, nil},
{"assent", -1, 3, nil},
{"eront", -1, 2, nil},
{"ât", -1, 3, nil},
{"ez", -1, 2, nil},
{"iez", 35, 2, nil},
{"eriez", 36, 2, nil},
{"assiez", 36, 3, nil},
{"erez", 35, 2, nil},
{"é", -1, 2, nil}
]
@a_4 [
{"ira", -1, 1, nil},
{"ie", -1, 1, nil},
{"isse", -1, 1, nil},
{"issante", -1, 1, nil},
{"i", -1, 1, nil},
{"irai", 4, 1, nil},
{"ir", -1, 1, nil},
{"iras", -1, 1, nil},
{"ies", -1, 1, nil},
{"îmes", -1, 1, nil},
{"isses", -1, 1, nil},
{"issantes", -1, 1, nil},
{"îtes", -1, 1, nil},
{"is", -1, 1, nil},
{"irais", 13, 1, nil},
{"issais", 13, 1, nil},
{"irions", -1, 1, nil},
{"issions", -1, 1, nil},
{"irons", -1, 1, nil},
{"issons", -1, 1, nil},
{"issants", -1, 1, nil},
{"it", -1, 1, nil},
{"irait", 21, 1, nil},
{"issait", 21, 1, nil},
{"issant", -1, 1, nil},
{"iraIent", -1, 1, nil},
{"issaIent", -1, 1, nil},
{"irent", -1, 1, nil},
{"issent", -1, 1, nil},
{"iront", -1, 1, nil},
{"ît", -1, 1, nil},
{"iriez", -1, 1, nil},
{"issiez", -1, 1, nil},
{"irez", -1, 1, nil},
{"issez", -1, 1, nil}
]
@a_5 [
{"iqU", -1, 3, nil},
{"abl", -1, 3, nil},
{"Ièr", -1, 4, nil},
{"ièr", -1, 4, nil},
{"eus", -1, 2, nil},
{"iv", -1, 1, nil}
]
@a_6 [
{"ic", -1, 2, nil},
{"abil", -1, 1, nil},
{"iv", -1, 3, nil}
]
@a_7 [
{"iqUe", -1, 1, nil},
{"atrice", -1, 2, nil},
{"ance", -1, 1, nil},
{"ence", -1, 5, nil},
{"logie", -1, 3, nil},
{"able", -1, 1, nil},
{"isme", -1, 1, nil},
{"euse", -1, 12, nil},
{"iste", -1, 1, nil},
{"ive", -1, 8, nil},
{"if", -1, 8, nil},
{"usion", -1, 4, nil},
{"ation", -1, 2, nil},
{"ution", -1, 4, nil},
{"ateur", -1, 2, nil},
{"iqUes", -1, 1, nil},
{"atrices", -1, 2, nil},
{"ances", -1, 1, nil},
{"ences", -1, 5, nil},
{"logies", -1, 3, nil},
{"ables", -1, 1, nil},
{"ismes", -1, 1, nil},
{"euses", -1, 12, nil},
{"istes", -1, 1, nil},
{"ives", -1, 8, nil},
{"ifs", -1, 8, nil},
{"usions", -1, 4, nil},
{"ations", -1, 2, nil},
{"utions", -1, 4, nil},
{"ateurs", -1, 2, nil},
{"ments", -1, 16, nil},
{"ements", 30, 6, nil},
{"issements", 31, 13, nil},
{"ités", -1, 7, nil},
{"ment", -1, 16, nil},
{"ement", 34, 6, nil},
{"issement", 35, 13, nil},
{"amment", 34, 14, nil},
{"emment", 34, 15, nil},
{"aux", -1, 10, nil},
{"eaux", 39, 9, nil},
{"eux", -1, 1, nil},
{"oux", -1, 11, nil},
{"ité", -1, 7, nil}
]
@a_8 [
{"col", -1, -1, nil},
{"ni", -1, 1, nil},
{"par", -1, -1, nil},
{"tap", -1, -1, nil}
]
@a_9 [
{"", -1, 7, nil},
{"H", 0, 6, nil},
{"He", 1, 4, nil},
{"Hi", 1, 5, nil},
{"I", 0, 1, nil},
{"U", 0, 2, nil},
{"Y", 0, 3, 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}}
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_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_un_accent(%Runtime{} = state) do
case (fn state ->
(fn ->
n = 1
case Enum.reduce_while(1..max(n, 0)//1, {:ok, state}, fn _, {:ok, s} ->
case (fn state ->
lift(state, Runtime.out_grouping_b(state, @g_v))
end).(s) do
{:ok, s2} -> {:cont, {:ok, s2}}
{:fail, s2} -> {:halt, {:fail, s2}}
end
end) do
{:fail, s} -> {:fail, s}
{:ok, state} ->
(fn loop_fn ->
loop_fn.(loop_fn, state)
end).(fn loop_fn, state ->
case (fn state ->
lift(state, Runtime.out_grouping_b(state, @g_v))
end).(state) do
{:ok, s} -> loop_fn.(loop_fn, s)
{:fail, _} -> {:ok, state}
end
end)
end
end).()
end).(state) do
{:ok, state} ->
case (fn state ->
{:ok, %{state | ket: state.cursor}}
end).(state) do
{:ok, state} ->
case (fn state ->
snowball_or(state,
fn state ->
lift(state, Runtime.eq_s_b(state, "é"))
end,
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_from(state, "e")}
end
r -> r
end
end
r -> r
end
end
defp r_un_double(%Runtime{} = state) do
case (fn state ->
snowball_test_b(state, fn state ->
(fn ->
case Runtime.find_among_b(state, @a_0) do
:fail -> {:fail, state}
{%Runtime{} = s, _} -> {:ok, s}
end
end).()
end)
end).(state) do
{:ok, state} ->
case (fn state ->
{:ok, %{state | ket: state.cursor}}
end).(state) do
{:ok, state} ->
case (fn state ->
next_codepoint_b(state)
end).(state) do
{:ok, state} ->
case (fn state ->
{:ok, %{state | bra: state.cursor}}
end).(state) do
{:ok, state} ->
{:ok, Runtime.slice_del(state)}
end
r -> r
end
end
r -> r
end
end
defp r_residual_suffix(%Runtime{} = state) do
case (fn state ->
{:ok, snowball_try(state, fn state ->
case (fn state ->
{:ok, %{state | ket: state.cursor}}
end).(state) do
{:ok, state} ->
case (fn state ->
lift(state, Runtime.eq_s_b(state, "s"))
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 ->
snowball_or(state,
fn state ->
lift(state, Runtime.eq_s_b(state, "Hi"))
end,
fn state ->
lift(state, Runtime.out_grouping_b(state, @g_keep_with_s))
end)
end)
end).(state) do
{:ok, state} ->
{:ok, Runtime.slice_del(state)}
r -> r
end
end
r -> r
end
end
end)}
end).(state) do
{:ok, state} ->
(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 ->
r_R2(state)
end).(state) do
{:ok, state} ->
case (fn state ->
snowball_or(state,
fn state ->
lift(state, Runtime.eq_s_b(state, "s"))
end,
fn state ->
lift(state, Runtime.eq_s_b(state, "t"))
end)
end).(state) do
{:ok, state} ->
{:ok, Runtime.slice_del(state)}
r -> r
end
r -> r
end
2 ->
{:ok, Runtime.slice_from(state, "i")}
3 ->
{: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
end
defp r_verb_suffix(%Runtime{} = state) do
(fn ->
old_limit = state.limit_backward
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} ->
state = %{state | ket: state.cursor, limit_backward: limit_state.cursor}
case Runtime.find_among_b(state, @a_3) 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 ->
r_R2(state)
end).(state) do
{:ok, state} ->
{:ok, Runtime.slice_del(state)}
r -> r
end
2 ->
{:ok, Runtime.slice_del(state)}
3 ->
case (fn state ->
{:ok, snowball_try(state, fn state ->
case (fn state ->
lift(state, Runtime.eq_s_b(state, "e"))
end).(state) do
{:ok, state} ->
case (fn state ->
r_RV(state)
end).(state) do
{:ok, state} ->
{:ok, %{state | bra: state.cursor}}
r -> r
end
r -> r
end
end)}
end).(state) do
{:ok, state} ->
{:ok, Runtime.slice_del(state)}
end
4 ->
case (fn state ->
(fn state ->
saved_c = state.cursor
case (fn state ->
(fn ->
case Runtime.find_among_b(state, @a_2) do
:fail -> {:fail, state}
{%Runtime{} = s, result} ->
state = s
case result do
1 ->
case (fn state ->
next_codepoint_b(state)
end).(state) do
{:ok, state} ->
if state.cursor <= state.limit_backward, do: {:ok, state}, else: {:fail, state}
r -> r
end
_ -> {:ok, s}
end
end
end).()
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 ->
{:ok, Runtime.slice_del(state)}
_ -> {:ok, state}
end
end
end
end).()
end
defp r_i_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_4) do
:fail -> {:fail, state}
{%Runtime{} = s, result} ->
state = %{s | bra: s.cursor}
case result do
1 ->
case (fn state ->
(fn state ->
saved_c = state.cursor
case (fn state ->
lift(state, Runtime.eq_s_b(state, "H"))
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 ->
lift(state, Runtime.out_grouping_b(state, @g_v))
end).(state) do
{:ok, state} ->
{:ok, Runtime.slice_del(state)}
r -> r
end
r -> r
end
_ -> {: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
(fn ->
state = %{state | ket: state.cursor}
case Runtime.find_among_b(state, @a_7) do
:fail -> {:fail, state}
{%Runtime{} = s, result} ->
state = %{s | bra: s.cursor}
case result do
1 ->
case (fn state ->
r_R2(state)
end).(state) do
{:ok, state} ->
{:ok, Runtime.slice_del(state)}
r -> r
end
2 ->
case (fn state ->
r_R2(state)
end).(state) do
{:ok, state} ->
case (fn state ->
{:ok, Runtime.slice_del(state)}
end).(state) do
{:ok, state} ->
{:ok, snowball_try(state, fn state ->
case (fn state ->
{:ok, %{state | ket: state.cursor}}
end).(state) do
{:ok, state} ->
case (fn state ->
lift(state, Runtime.eq_s_b(state, "ic"))
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 ->
r_R2(state)
end).(state) do
{:ok, state} ->
{:ok, Runtime.slice_del(state)}
r -> r
end
end,
fn state ->
{:ok, Runtime.slice_from(state, "iqU")}
end)
end
r -> r
end
end
end)}
end
r -> r
end
3 ->
case (fn state ->
r_R2(state)
end).(state) do
{:ok, state} ->
{:ok, Runtime.slice_from(state, "log")}
r -> r
end
4 ->
case (fn state ->
r_R2(state)
end).(state) do
{:ok, state} ->
{:ok, Runtime.slice_from(state, "u")}
r -> r
end
5 ->
case (fn state ->
r_R2(state)
end).(state) do
{:ok, state} ->
{:ok, Runtime.slice_from(state, "ent")}
r -> r
end
6 ->
case (fn state ->
r_RV(state)
end).(state) do
{:ok, state} ->
case (fn state ->
{:ok, Runtime.slice_del(state)}
end).(state) do
{:ok, state} ->
{:ok, snowball_try(state, fn state ->
(fn ->
state = %{state | ket: state.cursor}
case Runtime.find_among_b(state, @a_5) do
:fail -> {:fail, state}
{%Runtime{} = s, result} ->
state = %{s | bra: s.cursor}
case result do
1 ->
case (fn state ->
r_R2(state)
end).(state) do
{:ok, state} ->
case (fn state ->
{:ok, Runtime.slice_del(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_b(state, "at"))
end).(state) do
{:ok, state} ->
case (fn state ->
{:ok, %{state | bra: state.cursor}}
end).(state) do
{:ok, state} ->
case (fn state ->
r_R2(state)
end).(state) do
{:ok, state} ->
{:ok, Runtime.slice_del(state)}
r -> r
end
end
r -> r
end
end
end
r -> r
end
2 ->
snowball_or(state,
fn state ->
case (fn state ->
r_R2(state)
end).(state) do
{:ok, state} ->
{:ok, Runtime.slice_del(state)}
r -> r
end
end,
fn state ->
case (fn state ->
r_R1(state)
end).(state) do
{:ok, state} ->
{:ok, Runtime.slice_from(state, "eux")}
r -> r
end
end)
3 ->
case (fn state ->
r_R2(state)
end).(state) do
{:ok, state} ->
{:ok, Runtime.slice_del(state)}
r -> r
end
4 ->
case (fn state ->
r_RV(state)
end).(state) do
{:ok, state} ->
{:ok, Runtime.slice_from(state, "i")}
r -> r
end
_ -> {:ok, state}
end
end
end).()
end)}
end
r -> r
end
7 ->
case (fn state ->
r_R2(state)
end).(state) do
{:ok, state} ->
case (fn state ->
{:ok, Runtime.slice_del(state)}
end).(state) do
{:ok, state} ->
{:ok, snowball_try(state, fn state ->
(fn ->
state = %{state | ket: state.cursor}
case Runtime.find_among_b(state, @a_6) do
:fail -> {:fail, state}
{%Runtime{} = s, result} ->
state = %{s | bra: s.cursor}
case result do
1 ->
snowball_or(state,
fn state ->
case (fn state ->
r_R2(state)
end).(state) do
{:ok, state} ->
{:ok, Runtime.slice_del(state)}
r -> r
end
end,
fn state ->
{:ok, Runtime.slice_from(state, "abl")}
end)
2 ->
snowball_or(state,
fn state ->
case (fn state ->
r_R2(state)
end).(state) do
{:ok, state} ->
{:ok, Runtime.slice_del(state)}
r -> r
end
end,
fn state ->
{:ok, Runtime.slice_from(state, "iqU")}
end)
3 ->
case (fn state ->
r_R2(state)
end).(state) do
{:ok, state} ->
{:ok, Runtime.slice_del(state)}
r -> r
end
_ -> {:ok, state}
end
end
end).()
end)}
end
r -> r
end
8 ->
case (fn state ->
r_R2(state)
end).(state) do
{:ok, state} ->
case (fn state ->
{:ok, Runtime.slice_del(state)}
end).(state) do
{:ok, state} ->
{:ok, snowball_try(state, fn state ->
case (fn state ->
{:ok, %{state | ket: state.cursor}}
end).(state) do
{:ok, state} ->
case (fn state ->
lift(state, Runtime.eq_s_b(state, "at"))
end).(state) do
{:ok, state} ->
case (fn state ->
{:ok, %{state | bra: state.cursor}}
end).(state) do
{:ok, state} ->
case (fn state ->
r_R2(state)
end).(state) do
{:ok, state} ->
case (fn state ->
{:ok, Runtime.slice_del(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_b(state, "ic"))
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 ->
r_R2(state)
end).(state) do
{:ok, state} ->
{:ok, Runtime.slice_del(state)}
r -> r
end
end,
fn state ->
{:ok, Runtime.slice_from(state, "iqU")}
end)
end
r -> r
end
end
end
r -> r
end
end
r -> r
end
end
end)}
end
r -> r
end
9 ->
{:ok, Runtime.slice_from(state, "eau")}
10 ->
case (fn state ->
r_R1(state)
end).(state) do
{:ok, state} ->
{:ok, Runtime.slice_from(state, "al")}
r -> r
end
11 ->
case (fn state ->
lift(state, Runtime.in_grouping_b(state, @g_oux_ending))
end).(state) do
{:ok, state} ->
{:ok, Runtime.slice_from(state, "ou")}
r -> r
end
12 ->
snowball_or(state,
fn state ->
case (fn state ->
r_R2(state)
end).(state) do
{:ok, state} ->
{:ok, Runtime.slice_del(state)}
r -> r
end
end,
fn state ->
case (fn state ->
r_R1(state)
end).(state) do
{:ok, state} ->
{:ok, Runtime.slice_from(state, "eux")}
r -> r
end
end)
13 ->
case (fn state ->
r_R1(state)
end).(state) do
{:ok, state} ->
case (fn state ->
lift(state, Runtime.out_grouping_b(state, @g_v))
end).(state) do
{:ok, state} ->
{:ok, Runtime.slice_del(state)}
r -> r
end
r -> r
end
14 ->
case (fn state ->
r_RV(state)
end).(state) do
{:ok, state} ->
case (fn state ->
{:ok, Runtime.slice_from(state, "ant")}
end).(state) do
{:ok, s} -> {:fail, s}
end
r -> r
end
15 ->
case (fn state ->
r_RV(state)
end).(state) do
{:ok, state} ->
case (fn state ->
{:ok, Runtime.slice_from(state, "ent")}
end).(state) do
{:ok, s} -> {:fail, s}
end
r -> r
end
16 ->
case (fn state ->
snowball_test_b(state, fn state ->
case (fn state ->
lift(state, Runtime.in_grouping_b(state, @g_v))
end).(state) do
{:ok, state} ->
r_RV(state)
r -> r
end
end)
end).(state) do
{:ok, state} ->
case (fn state ->
{:ok, Runtime.slice_del(state)}
end).(state) do
{:ok, s} -> {:fail, s}
end
r -> r
end
_ -> {:ok, state}
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_elisions(%Runtime{} = state) do
case (fn state ->
{:ok, %{state | bra: state.cursor}}
end).(state) do
{:ok, state} ->
case (fn state ->
snowball_or(state,
fn state ->
lift(state, Runtime.in_grouping(state, @g_elision_char))
end,
fn state ->
lift(state, Runtime.eq_s(state, "qu"))
end)
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 ->
(fn state ->
saved_c = state.cursor
case (fn state ->
if state.cursor >= state.limit, 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).(state) do
{:ok, state} ->
{:ok, Runtime.slice_del(state)}
r -> r
end
end
r -> r
end
r -> r
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 ->
snowball_or(state,
fn state ->
snowball_or(state,
fn state ->
snowball_or(state,
fn state ->
snowball_or(state,
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 ->
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,
fn state ->
case (fn state ->
lift(state, Runtime.eq_s(state, "y"))
end).(state) do
{:ok, state} ->
case (fn state ->
{:ok, %{state | ket: state.cursor}}
end).(state) do
{:ok, state} ->
{:ok, Runtime.slice_from(state, "Y")}
end
r -> r
end
end)
end
r -> r
end
end,
fn state ->
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} ->
{:ok, Runtime.slice_from(state, "He")}
end
r -> r
end
end
end)
end,
fn state ->
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} ->
{:ok, Runtime.slice_from(state, "Hi")}
end
r -> r
end
end
end)
end,
fn state ->
case (fn state ->
{:ok, %{state | bra: state.cursor}}
end).(state) do
{:ok, state} ->
case (fn state ->
lift(state, Runtime.eq_s(state, "y"))
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, "Y")}
r -> r
end
end
r -> r
end
end
end)
end,
fn state ->
case (fn state ->
lift(state, Runtime.eq_s(state, "q"))
end).(state) do
{:ok, state} ->
case (fn state ->
{:ok, %{state | bra: state.cursor}}
end).(state) do
{:ok, 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} ->
{:ok, Runtime.slice_from(state, "U")}
end
r -> r
end
end
r -> r
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
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 ->
snowball_or(state,
fn state ->
case (fn state ->
lift(state, Runtime.in_grouping(state, @g_v))
end).(state) do
{:ok, state} ->
case (fn state ->
lift(state, Runtime.in_grouping(state, @g_v))
end).(state) do
{:ok, state} ->
next_codepoint(state)
r -> r
end
r -> r
end
end,
fn state ->
(fn ->
case Runtime.find_among(state, @a_8) do
:fail -> {:fail, state}
{%Runtime{} = s, result} ->
state = s
case result do
1 ->
lift(state, Runtime.in_grouping(state, @g_v))
_ -> {:ok, s}
end
end
end).()
end)
end,
fn state ->
case (fn state ->
next_codepoint(state)
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)
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_9) 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 ->
{:ok, Runtime.slice_from(state, "y")}
4 ->
{:ok, Runtime.slice_from(state, "ë")}
5 ->
{:ok, Runtime.slice_from(state, "ï")}
6 ->
{:ok, Runtime.slice_del(state)}
7 ->
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_elisions(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 ->
snowball_or(state,
fn state ->
case (fn state ->
snowball_test_b(state, fn state ->
snowball_or(state,
fn state ->
snowball_or(state,
fn state ->
r_standard_suffix(state)
end,
fn state ->
r_i_verb_suffix(state)
end)
end,
fn state ->
r_verb_suffix(state)
end)
end)
end).(state) do
{:ok, state} ->
{:ok, snowball_try(state, fn state ->
case (fn state ->
{:ok, %{state | ket: state.cursor}}
end).(state) do
{:ok, state} ->
snowball_or(state,
fn state ->
case (fn state ->
lift(state, Runtime.eq_s_b(state, "Y"))
end).(state) do
{:ok, state} ->
case (fn state ->
{:ok, %{state | bra: state.cursor}}
end).(state) do
{:ok, state} ->
{:ok, Runtime.slice_from(state, "i")}
end
r -> r
end
end,
fn 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} ->
{:ok, Runtime.slice_from(state, "c")}
end
r -> r
end
end)
end
end)}
r -> r
end
end,
fn state ->
r_residual_suffix(state)
end)
end)}
end).(state) do
{:ok, state} ->
case (fn state ->
{:ok, snowball_do_b(state, fn state ->
r_un_double(state)
end)}
end).(state) do
{:ok, state} ->
{:ok, snowball_do_b(state, fn state ->
r_un_accent(state)
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