my @Characters::Hiragana = ("\x3040".."\x309F").list;
my @Characters::Katakana = ("\x30A0".."\x30FF").list;
my %Characters::Table = {
    # Needed to correct what appears to be a bug with the Z operator
    my %h = @(@Characters::Hiragana) Z=> @(@Characters::Katakana);
    %h , |%h.antipairs};

my %kana_table = {
    'あ'=><あ　か　さ　た　な　は　ま　や　ら　わ　が　ざ　だ　ば　ぱ>,
    'い'=>(|<い　き し ち に ひ み>,Nil,|<り ゐ　ぎ じ ぢ び ぴ>),
    'う'=>(|<う　く　す　つ　ぬ　ふ　む　ゆ　る>,Nil,|<ぐ ず　づ　ぶ　ぷ>),
    'え'=>(|<え　け せ て ね へ め>,Nil,|<れ ゑ>,Nil,|<げ ぜ で べ ぺ>),
    'お'=>(|<お　こ　そ　と　の　ほ　も　よ　ろ　を>,Nil,|<ご ぞ　ど　ぼ　ぽ>),
    'ん'=>('ん',|(Nil xx 15))
};

my @godan = <う　つ　る　く　ぐ　ぶ　む　す>;

my @iru = %kana_table<い>.grep({ .defined });
my @eru = %kana_table<え>.grep({ .defined });

my regex ichidan { <?after @iru | @eru>'る'$ };

sub tail_tr(%table) {
    my @itms = %table.keys Z %table.values;
    return ({/ $^a $ / => $^b} for @itms);
}

sub conj_swap(Str $v1, Str $v2) {
    my @pairs = %kana_table{$v1} Z=> %kana_table{$v2};
    my %filt = @pairs.grep({ .value.defined and .key.defined });
    return tail_tr(%filt);
}

sub verb_class(Str $λ) {
    given $λ {
    when &ichidan {return 2}
    when / 'する'$ / {return 3}
    when / 'くる'$ / {return 4}
    when / @godan $ / {return 1}
    default {return Nil}
    }
}

module Conj {

    my %tables::godan = {
    :う(0),
    :く(1),
    :ぐ(2),
    :す(3),
    :つ(0),
    :ぶ(4),
    :ぬ(4),
    :む(4),
    :る(0),
    }

    my module Tabular {

    our multi sub Godan(Str $row, Str $suf) {
        nextwith($row, $suf xx 5);
    }
    our multi sub Godan(Str $row, List @suf) {
        my @tab = conj_swap('う',$row);
        my &func = sub (Str $λ) {
        my $s = @suf[%tables::godan{
                    $λ.substr(*-1)
                }
                ];
        my $c = $λ.trans(@tab);
        return $c ~ $s;
        }
        return &func;
    }

    our sub Ichidan(Str $suf) {
        my &func = sub (Str $λ) {
        $λ ~~ s/ 'る'$ /$suf/;
        return $λ;
        }
        return &func;
    }

    our sub Irregular(Str $su, Str $ku, Str $suf) {
        my &ichi = Ichidan($suf);
        my &func = sub (Str $λ) {
        my $s = (
            given ($λ) {
            when s/ <?after 'ん'>'ずる'$ /じる/ {succeed $_;}
            when s/ 'す'<?before 'る'> $ /$su/ {succeed $_;}
            when s/ 'く'<?before 'る'> $ /$ku/ {succeed $_;}
            default {return Nil;}
            }
        );
        return &ichi($s);
        }
        return &func;
    }

    our sub Entry(Str $row, \ω, Str $suf, Str $su, Str $ku) {
        my &dan5 = Godan($row, ω);
        my &dan1 = Ichidan($suf);
        my &irr = Irregular($su, $ku, $suf);
        my &func = sub (Str $λ) {
        given verb_class($λ) {
            when 4|3 {return &irr($λ);}
            when 2 {return &dan1($λ);}
            when 1 {return &dan5($λ);}
            default {return Nil;}
        }
        }
        return &func;
    }
    }

    our &Past = Tabular::Entry(
    'い',
    <った　いた　いだ　した　んだ>,
    'た',
    'し',
    'き');
    our &Negative = Tabular::Entry(
    |<あ　ない　ない　しない　こない>);
    our &PastNegative = Tabular::Entry(
    |<あ　なかった　なかった　しなかった　こなかった>);
    my &_impproto = Tabular::Entry(
    'え',
    '',
    'よ',
    'せよ',
    '');
    our sub Imperative(Str $λ) {
    if (verb_class($λ) == 4) {
        $λ ~~ s/'くる'/こい/;
        return $λ;
    }
    else {return _impproto($λ);}
    }

    our &Volitional = Tabular::Entry(
    |<お　う　よう　し　こ>);
    our &Conjunctive = Tabular::Entry(
    'い',
    <って　いて　いで　して　んで>,
    'て',
    'し',
    'き');
    our &Conditional = Tabular::Entry(
    |<え　ば　れば　す　く>);
}

module Polite {
    my sub _base(Str $λ = CALLER::<$_>) {
    my $s;
    if (verb_class($λ) == 3|4) {
        $s = S/ 'る' $ // given $λ;
    }
    else {
        $s = $λ.trans(conj_swap('う','い'));
    }
    return $s ~ 'ま';
    }

    our &Present = {  _base ~ 'す' };
    our &Past = {  _base ~ 'した' };
    our &Negative = {  _base ~ 'せん' };
    our &PastNegative = {  _base ~ 'せんでした' };
    our &Volitional = { _base ~ 'しょう' };
    our &Conjunctive = { _base ~ 'して' };
    our &Conditional = { _base ~ 'すれば' };
    our &Imperative = { _base ~ 'せ' }; # Not generally used
}