impl<T, U> {{ m.trait_ident }} for (T, U)
where
    T: {{ m.trait_ident }},
    U: {{ m.trait_ident }},
{
    {%- for f in m.fields %}

    {%- if f.is_message %}
    {%- if f.is_repeated %}
    {#- For repeated message f, each message has either `T` or `U` type, never be merged. -#}
    type {{ f.ident_camel_unesc }}MessageType<'this> where Self: 'this = ::puroro::Either<
        <T as {{ m.trait_ident }}>::{{ f.ident_camel_unesc }}MessageType<'this>,
        <U as {{ m.trait_ident }}>::{{ f.ident_camel_unesc }}MessageType<'this>,
    >;
    {%- else %} {#- if f.is_repeated #}
    {#- For non-repeated message f, the message is `T` and `U` merged type. -#}
    {#- There are 3+1 cases: `T` and `U` both exist, only `T`, only `U`, (and none of them). -#}
    type {{ f.ident_camel_unesc }}MessageType<'this> where Self: 'this = (
        ::std::option::Option<<T as {{ m.trait_ident }}>::{{ f.ident_camel_unesc }}MessageType<'this>>,
        ::std::option::Option<<U as {{ m.trait_ident }}>::{{ f.ident_camel_unesc }}MessageType<'this>>,
    );
    {%- endif %} {#- if f.is_repeated #}
    {%- endif %} {#- if f.is_message #}

    {%- if f.is_repeated %}

    {%- let merged_repeated_field_type %}
    {%- if f.is_message %}
    {%- let merged_repeated_field_type = "MergedRepeatedMessageField" %}
    {%- else %}
    {%- let merged_repeated_field_type = "MergedRepeatedField" %}
    {%- endif %}
    type {{ f.ident_camel_unesc }}RepeatedType<'this> where Self: 'this
        = ::puroro::internal::impls::merged::{{ merged_repeated_field_type }}<
            <T as {{ m.trait_ident }}>::{{ f.ident_camel_unesc }}RepeatedType<'this>,
            <U as {{ m.trait_ident }}>::{{ f.ident_camel_unesc }}RepeatedType<'this>,
        >;

    fn {{ f.ident }}<'this>(&'this self) -> Self::{{ f.ident_camel_unesc }}RepeatedType<'this>
    {
        ::puroro::internal::impls::merged::{{ merged_repeated_field_type }}::new(
            <T as {{ m.trait_ident }}>::{{ f.ident }}(&self.0),
            <U as {{ m.trait_ident }}>::{{ f.ident }}(&self.1),
        )
    }

    {%- else %} {#- if f.is_repeated #}

    {%- if !f.is_explicit_oneof_field %}
    fn {{ f.ident_unesc }}_opt<'this>(&'this self) -> Option<{{ f.trait_scalar_getter_type }}>
    {
        {%- if f.is_message %}
        match (
            <T as {{ m.trait_ident }}>::{{ f.ident_unesc }}_opt(&self.0),
            <U as {{ m.trait_ident }}>::{{ f.ident_unesc }}_opt(&self.1)
        ) {
            (None, None) => None,
            (Some(t), None) => Some((Some(t), None)),
            (None, Some(u)) => Some((None, Some(u))),
            (Some(t), Some(u)) => Some((Some(t), Some(u))),
        }
        {%- else %}
        <U as {{ m.trait_ident }}>::{{ f.ident_unesc }}_opt(&self.1)
            .or_else(|| <T as {{ m.trait_ident }}>::{{ f.ident_unesc }}_opt(&self.0))
        {%- endif %}
    }
    {%- endif %}

    {%- endif %} {#- if f.is_repeated #}

    {%- endfor %} {#- for f in m.fields #}

    {%- for oneof in m.oneofs %}
    fn {{ oneof.field_ident }}(&self) ->
        Option<
            super::_puroro_nested::{{ m.submodule_ident }}::_puroro_oneofs::
                {{ oneof.enum_ident }}{{ oneof.enum_maybe_gp_self }}
        >
    {
        use super::_puroro_nested::{{ m.submodule_ident }}::_puroro_oneofs::{{ oneof.enum_ident }} as E;
        Some(match (self.0.{{ oneof.field_ident }}(), self.1.{{ oneof.field_ident }}()) {
            (None, None) => { return None; },

            {%- for f in oneof.fields %}
            (
                Some(E::{{ f.ident }}({% if f.is_message %}left{% else %}_{% endif %})),
                Some(E::{{ f.ident }}(right))
            ) => {
                {%- if f.is_message %}
                E::{{ f.ident }}((Some(left), Some(right)))
                {%- else %}
                E::{{ f.ident }}(right)
                {%- endif %}
            }
            {%- endfor %}

            {%- for f in oneof.fields %}
            (_, Some(E::{{ f.ident }}(right))) => {
                {%- if f.is_message %}
                E::{{ f.ident }}((None, Some(right)))
                {%- else %}
                E::{{ f.ident }}(right)
                {%- endif %}
            }
            {%- endfor %}

            {%- for f in oneof.fields %}
            (Some(E::{{ f.ident }}(left)), None) => {
                {%- if f.is_message %}
                E::{{ f.ident }}((Some(left), None))
                {%- else %}
                E::{{ f.ident }}(left)
                {%- endif %}
            }
            {%- endfor %}
        })
    }
    {%- endfor %}
}