Constant python_ast::token::_IMPL_SERIALIZE_FOR_Tk [] [src]

const _IMPL_SERIALIZE_FOR_Tk: () = {
    extern crate serde as _serde;
    #[automatically_derived]
    impl <'a> _serde::Serialize for Tk<'a> {
        fn serialize<__S>(self: &Self, __serializer: __S)
         -> _serde::export::Result<<__S>::Ok, <__S>::Error> where
         __S: _serde::Serializer {
                                     let mut __serde_state =
                                         match _serde::Serializer::serialize_struct(__serializer,
                                                                                    "Tk",
                                                                                    0
                                                                                        +
                                                                                        1
                                                                                        +
                                                                                        1
                                                                                        +
                                                                                        1)
                                             {
                                             ::result::Result::Ok(val) => val,
                                             ::result::Result::Err(err) => {
                                                 return ::result::Result::Err(::convert::From::from(err))
                                             }
                                         };
                                     match _serde::ser::SerializeStruct::serialize_field(&mut __serde_state,
                                                                                         "id",
                                                                                         &self.id)
                                         {
                                         ::result::Result::Ok(val) => val,
                                         ::result::Result::Err(err) => {
                                             return ::result::Result::Err(::convert::From::from(err))
                                         }
                                     };
                                     match _serde::ser::SerializeStruct::serialize_field(&mut __serde_state,
                                                                                         "bytes",
                                                                                         {
                                                                                             struct __SerializeWith<'a:'__a,
                                                                                                                    '__a> {
                                                                                                 value: &'__a &'a [u8],
                                                                                                 phantom: _serde::export::PhantomData<Tk<'a>>,
                                                                                             }
                                                                                             impl <'a:'__a,
                                                                                                   '__a>
                                                                                              _serde::Serialize
                                                                                              for
                                                                                              __SerializeWith<'a,
                                                                                              '__a>
                                                                                              {
                                                                                                 fn serialize<__S>(self:
                                                                                                                       &Self,
                                                                                                                   __s:
                                                                                                                       __S)
                                                                                                  ->
                                                                                                      _serde::export::Result<<__S>::Ok,
                                                                                                                             <__S>::Error>
                                                                                                  where
                                                                                                  __S: _serde::Serializer {
                                                                                                                              serde_bytes::serialize(self.value,
                                                                                                                                                     __s)
                                                                                                                          }
                                                                                             }
                                                                                             &__SerializeWith{value:
                                                                                                                  &self.bytes,
                                                                                                              phantom:
                                                                                                                  _serde::export::PhantomData::<Tk<'a>>,}
                                                                                         })
                                         {
                                         ::result::Result::Ok(val) => val,
                                         ::result::Result::Err(err) => {
                                             return ::result::Result::Err(::convert::From::from(err))
                                         }
                                     };
                                     match _serde::ser::SerializeStruct::serialize_field(&mut __serde_state,
                                                                                         "tag",
                                                                                         &self.tag)
                                         {
                                         ::result::Result::Ok(val) => val,
                                         ::result::Result::Err(err) => {
                                             return ::result::Result::Err(::convert::From::from(err))
                                         }
                                     };
                                     _serde::ser::SerializeStruct::end(__serde_state)
                                 }
    }
}