From b475ae35d247e789e79f959273ddde0de48bd856 Mon Sep 17 00:00:00 2001 From: nickray Date: Thu, 10 Jun 2021 20:35:56 +0000 Subject: [PATCH] deploy: 5ff4cc4870cfae9c15ed67ec6f2a2834da023659 --- FiraSans-Medium.woff2 | Bin 0 -> 132780 bytes FiraSans-Regular.woff2 | Bin 0 -> 129188 bytes ayu.css | 2 +- cfg_if/all.html | 9 +- cfg_if/index.html | 11 +- cfg_if/macro.cfg_if.html | 9 +- crates.js | 1 + dark.css | 2 +- delog/all.html | 9 +- delog/enum.Level.html | 105 +- delog/enum.LevelFilter.html | 95 +- delog/fn.dequeue.html | 9 +- delog/fn.enqueue.html | 9 +- delog/fn.logger.html | 9 +- delog/fn.try_enqueue.html | 15 +- delog/hex/fn.HexStr.html | 9 +- delog/hex/index.html | 9 +- delog/hex/struct.HexStr.html | 27 +- delog/hex/struct.U1.html | 27 +- delog/hex/trait.Separator.html | 9 +- delog/hex/trait.Unsigned.html | 9 +- delog/index.html | 47 +- delog/macro.delog.html | 13 +- delog/macro.generate_macros.html | 9 +- delog/macro.hex_str.html | 9 +- delog/macro.hexstr.html | 9 +- delog/macro.try_log.html | 9 +- delog/render/fn.default.html | 9 +- delog/render/fn.render_arguments.html | 9 +- delog/render/fn.render_record.html | 9 +- delog/render/index.html | 9 +- delog/render/struct.DefaultRenderer.html | 33 +- delog/render/struct.RipgrepRenderer.html | 33 +- delog/sidebar-items.js | 2 +- delog/struct.Record.html | 49 +- delog/struct.Statistics.html | 29 +- delog/trait.Delogger.html | 11 +- delog/trait.Flusher.html | 9 +- delog/trait.Renderer.html | 9 +- delog/trait.State.html | 9 +- delog/trait.TryLog.html | 11 +- delog/trait.TryLogWithStatistics.html | 9 +- flexiber/all.html | 9 +- flexiber/derive.Decodable.html | 12 +- flexiber/derive.Encodable.html | 12 +- flexiber/enum.Class.html | 31 +- flexiber/enum.ErrorKind.html | 31 +- flexiber/index.html | 11 +- flexiber/macro.debug.html | 9 +- flexiber/macro.debug_now.html | 9 +- flexiber/macro.error.html | 9 +- flexiber/macro.error_now.html | 9 +- flexiber/macro.info.html | 9 +- flexiber/macro.info_now.html | 9 +- flexiber/macro.log.html | 9 +- flexiber/macro.log_now.html | 9 +- flexiber/macro.trace.html | 9 +- flexiber/macro.trace_now.html | 9 +- flexiber/macro.try_debug.html | 9 +- flexiber/macro.try_debug_now.html | 9 +- flexiber/macro.try_error.html | 9 +- flexiber/macro.try_error_now.html | 9 +- flexiber/macro.try_info.html | 9 +- flexiber/macro.try_info_now.html | 9 +- flexiber/macro.try_log_now.html | 9 +- flexiber/macro.try_trace.html | 9 +- flexiber/macro.try_trace_now.html | 9 +- flexiber/macro.try_warn.html | 9 +- flexiber/macro.try_warn_now.html | 9 +- flexiber/macro.warn.html | 9 +- flexiber/macro.warn_now.html | 9 +- flexiber/sidebar-items.js | 2 +- flexiber/struct.Decoder.html | 29 +- flexiber/struct.Encoder.html | 27 +- flexiber/struct.Error.html | 29 +- flexiber/struct.Length.html | 45 +- flexiber/struct.SimpleTag.html | 33 +- flexiber/struct.Slice.html | 29 +- flexiber/struct.Tag.html | 31 +- flexiber/struct.TaggedValue.html | 31 +- flexiber/trait.Container.html | 11 +- flexiber/trait.Decodable.html | 9 +- flexiber/trait.Encodable.html | 77 +- flexiber/trait.TagLike.html | 9 +- flexiber/trait.Tagged.html | 9 +- flexiber/type.Result.html | 9 +- flexiber/type.TaggedSlice.html | 11 +- flexiber_derive/all.html | 9 +- flexiber_derive/derive.Decodable.html | 12 +- flexiber_derive/derive.Encodable.html | 12 +- flexiber_derive/index.html | 9 +- implementors/core/clone/trait.Clone.js | 12 +- implementors/core/cmp/trait.Eq.js | 10 +- implementors/core/cmp/trait.Ord.js | 8 +- implementors/core/cmp/trait.PartialEq.js | 10 +- implementors/core/cmp/trait.PartialOrd.js | 8 +- implementors/core/convert/trait.AsRef.js | 2 +- implementors/core/convert/trait.From.js | 6 +- implementors/core/convert/trait.TryFrom.js | 2 +- implementors/core/default/trait.Default.js | 6 +- implementors/core/fmt/trait.Debug.js | 12 +- implementors/core/fmt/trait.Display.js | 10 +- implementors/core/fmt/trait.LowerHex.js | 2 +- implementors/core/fmt/trait.UpperHex.js | 2 +- implementors/core/hash/trait.Hash.js | 8 +- .../core/iter/traits/collect/trait.Extend.js | 4 +- .../iter/traits/collect/trait.FromIterator.js | 4 +- .../iter/traits/collect/trait.IntoIterator.js | 4 +- .../double_ended/trait.DoubleEndedIterator.js | 2 +- .../exact_size/trait.ExactSizeIterator.js | 2 +- .../iter/traits/iterator/trait.Iterator.js | 4 +- implementors/core/marker/trait.Copy.js | 12 +- implementors/core/marker/trait.Freeze.js | 12 +- implementors/core/marker/trait.Send.js | 12 +- .../core/marker/trait.StructuralEq.js | 8 +- .../core/marker/trait.StructuralPartialEq.js | 8 +- implementors/core/marker/trait.Sync.js | 12 +- implementors/core/marker/trait.Unpin.js | 12 +- implementors/core/ops/arith/trait.Add.js | 2 +- implementors/core/ops/deref/trait.Deref.js | 2 +- implementors/core/ops/deref/trait.DerefMut.js | 2 +- implementors/core/ops/drop/trait.Drop.js | 2 +- implementors/core/ops/index/trait.Index.js | 2 +- implementors/core/ops/index/trait.IndexMut.js | 2 +- implementors/core/str/traits/trait.FromStr.js | 4 +- .../ident_fragment/trait.IdentFragment.js | 2 +- .../quote/to_tokens/trait.ToTokens.js | 4 +- implementors/std/error/trait.Error.js | 4 +- implementors/std/panic/trait.RefUnwindSafe.js | 6 +- implementors/std/panic/trait.UnwindSafe.js | 6 +- light.css | 2 +- log/all.html | 7 +- log/constant.STATIC_MAX_LEVEL.html | 7 +- log/enum.Level.html | 51 +- log/enum.LevelFilter.html | 41 +- log/fn.logger.html | 7 +- log/fn.max_level.html | 7 +- log/fn.set_logger.html | 7 +- log/fn.set_logger_racy.html | 7 +- log/fn.set_max_level.html | 7 +- log/index.html | 23 +- log/macro.debug.html | 7 +- log/macro.error.html | 7 +- log/macro.info.html | 7 +- log/macro.log.html | 7 +- log/macro.log_enabled.html | 7 +- log/macro.trace.html | 7 +- log/macro.warn.html | 7 +- log/sidebar-items.js | 2 +- log/struct.Metadata.html | 45 +- log/struct.MetadataBuilder.html | 43 +- log/struct.ParseLevelError.html | 25 +- log/struct.Record.html | 27 +- log/struct.RecordBuilder.html | 27 +- log/struct.SetLoggerError.html | 25 +- log/trait.Log.html | 7 +- main.js | 6 +- noscript.css | 2 +- proc_macro2/all.html | 9 +- proc_macro2/enum.Delimiter.html | 45 +- proc_macro2/enum.Spacing.html | 45 +- proc_macro2/enum.TokenTree.html | 71 +- proc_macro2/index.html | 15 +- proc_macro2/sidebar-items.js | 2 +- proc_macro2/struct.Group.html | 61 +- proc_macro2/struct.Ident.html | 87 +- proc_macro2/struct.LexError.html | 41 +- proc_macro2/struct.Literal.html | 167 +- proc_macro2/struct.Punct.html | 61 +- proc_macro2/struct.Span.html | 55 +- proc_macro2/struct.TokenStream.html | 87 +- proc_macro2/token_stream/index.html | 11 +- proc_macro2/token_stream/sidebar-items.js | 2 +- proc_macro2/token_stream/struct.IntoIter.html | 192 +- quote/all.html | 9 +- quote/index.html | 15 +- quote/macro.format_ident.html | 9 +- quote/macro.quote.html | 15 +- quote/macro.quote_spanned.html | 11 +- quote/trait.IdentFragment.html | 9 +- quote/trait.ToTokens.html | 9 +- quote/trait.TokenStreamExt.html | 9 +- rustdoc.css | 2 +- search-index.js | 22 +- settings.html | 9 +- source-script.js | 2 +- src/cfg_if/lib.rs.html | 9 +- src/delog/hex.rs.html | 9 +- src/delog/lib.rs.html | 9 +- src/delog/logger.rs.html | 47 +- src/delog/macros.rs.html | 11 +- src/delog/render.rs.html | 19 +- src/flexiber/decoder.rs.html | 9 +- src/flexiber/encoder.rs.html | 9 +- src/flexiber/error.rs.html | 9 +- src/flexiber/header.rs.html | 9 +- src/flexiber/length.rs.html | 9 +- src/flexiber/lib.rs.html | 9 +- src/flexiber/simpletag.rs.html | 9 +- src/flexiber/slice.rs.html | 9 +- src/flexiber/tag.rs.html | 9 +- src/flexiber/tagged.rs.html | 9 +- src/flexiber/traits.rs.html | 13 +- src/flexiber_derive/decodable.rs.html | 9 +- src/flexiber_derive/encodable.rs.html | 9 +- src/flexiber_derive/lib.rs.html | 9 +- src/log/lib.rs.html | 7 +- src/log/macros.rs.html | 7 +- src/proc_macro2/detection.rs.html | 9 +- src/proc_macro2/fallback.rs.html | 71 +- src/proc_macro2/lib.rs.html | 97 +- src/proc_macro2/marker.rs.html | 9 +- src/proc_macro2/parse.rs.html | 219 +- src/proc_macro2/wrapper.rs.html | 107 +- src/quote/ext.rs.html | 9 +- src/quote/format.rs.html | 9 +- src/quote/ident_fragment.rs.html | 9 +- src/quote/lib.rs.html | 9 +- src/quote/runtime.rs.html | 9 +- src/quote/spanned.rs.html | 9 +- src/quote/to_tokens.rs.html | 9 +- src/syn/attr.rs.html | 39 +- src/syn/await.rs.html | 9 +- src/syn/bigint.rs.html | 9 +- src/syn/buffer.rs.html | 9 +- src/syn/custom_keyword.rs.html | 11 +- src/syn/custom_punctuation.rs.html | 11 +- src/syn/data.rs.html | 73 +- src/syn/derive.rs.html | 35 +- src/syn/discouraged.rs.html | 11 +- src/syn/error.rs.html | 13 +- src/syn/export.rs.html | 9 +- src/syn/expr.rs.html | 619 +++-- src/syn/ext.rs.html | 9 +- src/syn/gen/clone.rs.html | 9 +- src/syn/gen/debug.rs.html | 9 +- src/syn/gen/eq.rs.html | 9 +- src/syn/gen/hash.rs.html | 9 +- src/syn/gen/up/gen_helper.rs.html | 9 +- src/syn/gen/visit.rs.html | 765 +++---- src/syn/generics.rs.html | 39 +- src/syn/group.rs.html | 9 +- src/syn/ident.rs.html | 9 +- src/syn/lib.rs.html | 2011 +++++++++-------- src/syn/lifetime.rs.html | 11 +- src/syn/lit.rs.html | 25 +- src/syn/lookahead.rs.html | 9 +- src/syn/mac.rs.html | 9 +- src/syn/macros.rs.html | 9 +- src/syn/op.rs.html | 9 +- src/syn/parse.rs.html | 9 +- src/syn/parse_macro_input.rs.html | 9 +- src/syn/parse_quote.rs.html | 9 +- src/syn/path.rs.html | 195 +- src/syn/print.rs.html | 9 +- src/syn/punctuated.rs.html | 11 +- src/syn/sealed.rs.html | 9 +- src/syn/span.rs.html | 9 +- src/syn/spanned.rs.html | 9 +- src/syn/thread.rs.html | 9 +- src/syn/token.rs.html | 9 +- src/syn/tt.rs.html | 9 +- src/syn/ty.rs.html | 21 +- src/syn/verbatim.rs.html | 9 +- src/synstructure/lib.rs.html | 9 +- src/synstructure/macros.rs.html | 9 +- src/unicode_xid/lib.rs.html | 27 +- src/unicode_xid/tables.rs.html | 7 +- storage.js | 2 +- syn/all.html | 9 +- syn/buffer/index.html | 9 +- syn/buffer/struct.Cursor.html | 37 +- syn/buffer/struct.TokenBuffer.html | 27 +- syn/enum.AttrStyle.html | 39 +- syn/enum.BinOp.html | 43 +- syn/enum.Data.html | 39 +- syn/enum.Expr.html | 47 +- syn/enum.Fields.html | 47 +- syn/enum.GenericArgument.html | 47 +- syn/enum.GenericParam.html | 45 +- syn/enum.Lit.html | 47 +- syn/enum.MacroDelimiter.html | 39 +- syn/enum.Member.html | 56 +- syn/enum.Meta.html | 57 +- syn/enum.NestedMeta.html | 51 +- syn/enum.PathArguments.html | 47 +- syn/enum.ReturnType.html | 49 +- syn/enum.StrStyle.html | 27 +- syn/enum.TraitBoundModifier.html | 47 +- syn/enum.Type.html | 47 +- syn/enum.TypeParamBound.html | 51 +- syn/enum.UnOp.html | 43 +- syn/enum.Visibility.html | 45 +- syn/enum.WherePredicate.html | 53 +- syn/ext/index.html | 9 +- syn/ext/trait.IdentExt.html | 11 +- syn/fn.parse.html | 13 +- syn/fn.parse2.html | 9 +- syn/fn.parse_str.html | 9 +- syn/index.html | 21 +- syn/macro.Token.html | 9 +- syn/macro.braced.html | 9 +- syn/macro.bracketed.html | 9 +- syn/macro.custom_keyword.html | 9 +- syn/macro.custom_punctuation.html | 9 +- syn/macro.parenthesized.html | 9 +- syn/macro.parse_macro_input.html | 9 +- syn/macro.parse_quote.html | 9 +- syn/parse/discouraged/index.html | 9 +- syn/parse/discouraged/trait.Speculative.html | 27 +- syn/parse/index.html | 11 +- syn/parse/struct.Error.html | 51 +- syn/parse/struct.Lookahead1.html | 27 +- syn/parse/struct.Nothing.html | 27 +- syn/parse/struct.ParseBuffer.html | 33 +- syn/parse/struct.StepCursor.html | 35 +- syn/parse/trait.Parse.html | 9 +- syn/parse/trait.Parser.html | 9 +- syn/parse/trait.Peek.html | 9 +- syn/parse/type.ParseStream.html | 9 +- syn/parse/type.Result.html | 9 +- syn/punctuated/enum.Pair.html | 43 +- syn/punctuated/index.html | 9 +- syn/punctuated/struct.IntoIter.html | 192 +- syn/punctuated/struct.IntoPairs.html | 192 +- syn/punctuated/struct.Iter.html | 192 +- syn/punctuated/struct.IterMut.html | 184 +- syn/punctuated/struct.Pairs.html | 192 +- syn/punctuated/struct.PairsMut.html | 184 +- syn/punctuated/struct.Punctuated.html | 53 +- syn/spanned/index.html | 13 +- syn/spanned/trait.Spanned.html | 9 +- syn/struct.Abi.html | 47 +- ...struct.AngleBracketedGenericArguments.html | 47 +- syn/struct.Attribute.html | 49 +- syn/struct.BareFnArg.html | 47 +- syn/struct.Binding.html | 47 +- syn/struct.BoundLifetimes.html | 49 +- syn/struct.ConstParam.html | 47 +- syn/struct.Constraint.html | 45 +- syn/struct.DataEnum.html | 39 +- syn/struct.DataStruct.html | 39 +- syn/struct.DataUnion.html | 39 +- syn/struct.DeriveInput.html | 45 +- syn/struct.Error.html | 51 +- syn/struct.ExprArray.html | 31 +- syn/struct.ExprAssign.html | 31 +- syn/struct.ExprAssignOp.html | 31 +- syn/struct.ExprAsync.html | 31 +- syn/struct.ExprAwait.html | 31 +- syn/struct.ExprBinary.html | 45 +- syn/struct.ExprBlock.html | 31 +- syn/struct.ExprBox.html | 31 +- syn/struct.ExprBreak.html | 31 +- syn/struct.ExprCall.html | 45 +- syn/struct.ExprCast.html | 45 +- syn/struct.ExprClosure.html | 31 +- syn/struct.ExprContinue.html | 31 +- syn/struct.ExprField.html | 45 +- syn/struct.ExprForLoop.html | 31 +- syn/struct.ExprGroup.html | 31 +- syn/struct.ExprIf.html | 31 +- syn/struct.ExprIndex.html | 45 +- syn/struct.ExprLet.html | 31 +- syn/struct.ExprLit.html | 47 +- syn/struct.ExprLoop.html | 31 +- syn/struct.ExprMacro.html | 31 +- syn/struct.ExprMatch.html | 31 +- syn/struct.ExprMethodCall.html | 31 +- syn/struct.ExprParen.html | 45 +- syn/struct.ExprPath.html | 47 +- syn/struct.ExprRange.html | 31 +- syn/struct.ExprReference.html | 31 +- syn/struct.ExprRepeat.html | 31 +- syn/struct.ExprReturn.html | 31 +- syn/struct.ExprStruct.html | 31 +- syn/struct.ExprTry.html | 31 +- syn/struct.ExprTryBlock.html | 31 +- syn/struct.ExprTuple.html | 31 +- syn/struct.ExprType.html | 31 +- syn/struct.ExprUnary.html | 45 +- syn/struct.ExprUnsafe.html | 31 +- syn/struct.ExprWhile.html | 31 +- syn/struct.ExprYield.html | 31 +- syn/struct.Field.html | 49 +- syn/struct.FieldsNamed.html | 45 +- syn/struct.FieldsUnnamed.html | 45 +- syn/struct.Generics.html | 55 +- syn/struct.Ident.html | 102 +- syn/struct.ImplGenerics.html | 53 +- syn/struct.Index.html | 56 +- syn/struct.Lifetime.html | 61 +- syn/struct.LifetimeDef.html | 49 +- syn/struct.LitBool.html | 43 +- syn/struct.LitByte.html | 43 +- syn/struct.LitByteStr.html | 43 +- syn/struct.LitChar.html | 43 +- syn/struct.LitFloat.html | 45 +- syn/struct.LitInt.html | 45 +- syn/struct.LitStr.html | 43 +- syn/struct.Macro.html | 47 +- syn/struct.MetaList.html | 49 +- syn/struct.MetaNameValue.html | 49 +- syn/struct.ParenthesizedGenericArguments.html | 47 +- syn/struct.Path.html | 55 +- syn/struct.PathSegment.html | 47 +- syn/struct.PredicateEq.html | 47 +- syn/struct.PredicateLifetime.html | 47 +- syn/struct.PredicateType.html | 47 +- syn/struct.QSelf.html | 39 +- syn/struct.TraitBound.html | 49 +- syn/struct.Turbofish.html | 53 +- syn/struct.TypeArray.html | 47 +- syn/struct.TypeBareFn.html | 47 +- syn/struct.TypeGenerics.html | 55 +- syn/struct.TypeGroup.html | 47 +- syn/struct.TypeImplTrait.html | 47 +- syn/struct.TypeInfer.html | 47 +- syn/struct.TypeMacro.html | 47 +- syn/struct.TypeNever.html | 47 +- syn/struct.TypeParam.html | 49 +- syn/struct.TypeParen.html | 47 +- syn/struct.TypePath.html | 47 +- syn/struct.TypePtr.html | 47 +- syn/struct.TypeReference.html | 47 +- syn/struct.TypeSlice.html | 47 +- syn/struct.TypeTraitObject.html | 49 +- syn/struct.TypeTuple.html | 47 +- syn/struct.Variadic.html | 45 +- syn/struct.Variant.html | 45 +- syn/struct.VisCrate.html | 45 +- syn/struct.VisPublic.html | 45 +- syn/struct.VisRestricted.html | 45 +- syn/struct.WhereClause.html | 47 +- syn/token/index.html | 9 +- syn/token/struct.Abstract.html | 47 +- syn/token/struct.Add.html | 47 +- syn/token/struct.AddEq.html | 47 +- syn/token/struct.And.html | 47 +- syn/token/struct.AndAnd.html | 47 +- syn/token/struct.AndEq.html | 47 +- syn/token/struct.As.html | 47 +- syn/token/struct.Async.html | 47 +- syn/token/struct.At.html | 47 +- syn/token/struct.Auto.html | 47 +- syn/token/struct.Await.html | 47 +- syn/token/struct.Bang.html | 47 +- syn/token/struct.Become.html | 47 +- syn/token/struct.Box.html | 47 +- syn/token/struct.Brace.html | 41 +- syn/token/struct.Bracket.html | 41 +- syn/token/struct.Break.html | 47 +- syn/token/struct.Caret.html | 47 +- syn/token/struct.CaretEq.html | 47 +- syn/token/struct.Colon.html | 47 +- syn/token/struct.Colon2.html | 47 +- syn/token/struct.Comma.html | 47 +- syn/token/struct.Const.html | 47 +- syn/token/struct.Continue.html | 47 +- syn/token/struct.Crate.html | 47 +- syn/token/struct.Default.html | 47 +- syn/token/struct.Div.html | 47 +- syn/token/struct.DivEq.html | 47 +- syn/token/struct.Do.html | 47 +- syn/token/struct.Dollar.html | 47 +- syn/token/struct.Dot.html | 47 +- syn/token/struct.Dot2.html | 47 +- syn/token/struct.Dot3.html | 47 +- syn/token/struct.DotDotEq.html | 47 +- syn/token/struct.Dyn.html | 47 +- syn/token/struct.Else.html | 47 +- syn/token/struct.Enum.html | 47 +- syn/token/struct.Eq.html | 47 +- syn/token/struct.EqEq.html | 47 +- syn/token/struct.Extern.html | 47 +- syn/token/struct.FatArrow.html | 47 +- syn/token/struct.Final.html | 47 +- syn/token/struct.Fn.html | 47 +- syn/token/struct.For.html | 47 +- syn/token/struct.Ge.html | 47 +- syn/token/struct.Group.html | 41 +- syn/token/struct.Gt.html | 47 +- syn/token/struct.If.html | 47 +- syn/token/struct.Impl.html | 47 +- syn/token/struct.In.html | 47 +- syn/token/struct.LArrow.html | 47 +- syn/token/struct.Le.html | 47 +- syn/token/struct.Let.html | 47 +- syn/token/struct.Loop.html | 47 +- syn/token/struct.Lt.html | 47 +- syn/token/struct.Macro.html | 47 +- syn/token/struct.Match.html | 47 +- syn/token/struct.Mod.html | 47 +- syn/token/struct.Move.html | 47 +- syn/token/struct.MulEq.html | 47 +- syn/token/struct.Mut.html | 47 +- syn/token/struct.Ne.html | 47 +- syn/token/struct.Or.html | 47 +- syn/token/struct.OrEq.html | 47 +- syn/token/struct.OrOr.html | 47 +- syn/token/struct.Override.html | 47 +- syn/token/struct.Paren.html | 41 +- syn/token/struct.Pound.html | 47 +- syn/token/struct.Priv.html | 47 +- syn/token/struct.Pub.html | 47 +- syn/token/struct.Question.html | 47 +- syn/token/struct.RArrow.html | 47 +- syn/token/struct.Ref.html | 47 +- syn/token/struct.Rem.html | 47 +- syn/token/struct.RemEq.html | 47 +- syn/token/struct.Return.html | 47 +- syn/token/struct.SelfType.html | 47 +- syn/token/struct.SelfValue.html | 47 +- syn/token/struct.Semi.html | 47 +- syn/token/struct.Shl.html | 47 +- syn/token/struct.ShlEq.html | 47 +- syn/token/struct.Shr.html | 47 +- syn/token/struct.ShrEq.html | 47 +- syn/token/struct.Star.html | 47 +- syn/token/struct.Static.html | 47 +- syn/token/struct.Struct.html | 47 +- syn/token/struct.Sub.html | 47 +- syn/token/struct.SubEq.html | 47 +- syn/token/struct.Super.html | 47 +- syn/token/struct.Tilde.html | 47 +- syn/token/struct.Trait.html | 47 +- syn/token/struct.Try.html | 47 +- syn/token/struct.Type.html | 47 +- syn/token/struct.Typeof.html | 47 +- syn/token/struct.Underscore.html | 47 +- syn/token/struct.Union.html | 47 +- syn/token/struct.Unsafe.html | 47 +- syn/token/struct.Unsized.html | 47 +- syn/token/struct.Use.html | 47 +- syn/token/struct.Virtual.html | 47 +- syn/token/struct.Where.html | 47 +- syn/token/struct.While.html | 47 +- syn/token/struct.Yield.html | 47 +- syn/token/trait.Token.html | 9 +- syn/type.AttributeArgs.html | 9 +- syn/type.Result.html | 9 +- syn/visit/fn.visit_abi.html | 7 +- ...sit_angle_bracketed_generic_arguments.html | 7 +- syn/visit/fn.visit_attr_style.html | 7 +- syn/visit/fn.visit_attribute.html | 7 +- syn/visit/fn.visit_bare_fn_arg.html | 7 +- syn/visit/fn.visit_bin_op.html | 7 +- syn/visit/fn.visit_binding.html | 7 +- syn/visit/fn.visit_bound_lifetimes.html | 7 +- syn/visit/fn.visit_const_param.html | 7 +- syn/visit/fn.visit_constraint.html | 7 +- syn/visit/fn.visit_data.html | 7 +- syn/visit/fn.visit_data_enum.html | 7 +- syn/visit/fn.visit_data_struct.html | 7 +- syn/visit/fn.visit_data_union.html | 7 +- syn/visit/fn.visit_derive_input.html | 7 +- syn/visit/fn.visit_expr.html | 7 +- syn/visit/fn.visit_expr_binary.html | 7 +- syn/visit/fn.visit_expr_call.html | 7 +- syn/visit/fn.visit_expr_cast.html | 7 +- syn/visit/fn.visit_expr_field.html | 7 +- syn/visit/fn.visit_expr_index.html | 7 +- syn/visit/fn.visit_expr_lit.html | 7 +- syn/visit/fn.visit_expr_paren.html | 7 +- syn/visit/fn.visit_expr_path.html | 7 +- syn/visit/fn.visit_expr_unary.html | 7 +- syn/visit/fn.visit_field.html | 7 +- syn/visit/fn.visit_fields.html | 7 +- syn/visit/fn.visit_fields_named.html | 7 +- syn/visit/fn.visit_fields_unnamed.html | 7 +- syn/visit/fn.visit_generic_argument.html | 7 +- syn/visit/fn.visit_generic_param.html | 7 +- syn/visit/fn.visit_generics.html | 7 +- syn/visit/fn.visit_ident.html | 7 +- syn/visit/fn.visit_index.html | 7 +- syn/visit/fn.visit_lifetime.html | 7 +- syn/visit/fn.visit_lifetime_def.html | 7 +- syn/visit/fn.visit_lit.html | 7 +- syn/visit/fn.visit_lit_bool.html | 7 +- syn/visit/fn.visit_lit_byte.html | 7 +- syn/visit/fn.visit_lit_byte_str.html | 7 +- syn/visit/fn.visit_lit_char.html | 7 +- syn/visit/fn.visit_lit_float.html | 7 +- syn/visit/fn.visit_lit_int.html | 7 +- syn/visit/fn.visit_lit_str.html | 7 +- syn/visit/fn.visit_macro.html | 7 +- syn/visit/fn.visit_macro_delimiter.html | 7 +- syn/visit/fn.visit_member.html | 7 +- syn/visit/fn.visit_meta.html | 7 +- syn/visit/fn.visit_meta_list.html | 7 +- syn/visit/fn.visit_meta_name_value.html | 7 +- syn/visit/fn.visit_nested_meta.html | 7 +- ...visit_parenthesized_generic_arguments.html | 7 +- syn/visit/fn.visit_path.html | 7 +- syn/visit/fn.visit_path_arguments.html | 7 +- syn/visit/fn.visit_path_segment.html | 7 +- syn/visit/fn.visit_predicate_eq.html | 7 +- syn/visit/fn.visit_predicate_lifetime.html | 7 +- syn/visit/fn.visit_predicate_type.html | 7 +- syn/visit/fn.visit_qself.html | 7 +- syn/visit/fn.visit_return_type.html | 7 +- syn/visit/fn.visit_span.html | 7 +- syn/visit/fn.visit_trait_bound.html | 7 +- syn/visit/fn.visit_trait_bound_modifier.html | 7 +- syn/visit/fn.visit_type.html | 7 +- syn/visit/fn.visit_type_array.html | 7 +- syn/visit/fn.visit_type_bare_fn.html | 7 +- syn/visit/fn.visit_type_group.html | 7 +- syn/visit/fn.visit_type_impl_trait.html | 7 +- syn/visit/fn.visit_type_infer.html | 7 +- syn/visit/fn.visit_type_macro.html | 7 +- syn/visit/fn.visit_type_never.html | 7 +- syn/visit/fn.visit_type_param.html | 7 +- syn/visit/fn.visit_type_param_bound.html | 7 +- syn/visit/fn.visit_type_paren.html | 7 +- syn/visit/fn.visit_type_path.html | 7 +- syn/visit/fn.visit_type_ptr.html | 7 +- syn/visit/fn.visit_type_reference.html | 7 +- syn/visit/fn.visit_type_slice.html | 7 +- syn/visit/fn.visit_type_trait_object.html | 7 +- syn/visit/fn.visit_type_tuple.html | 7 +- syn/visit/fn.visit_un_op.html | 7 +- syn/visit/fn.visit_variadic.html | 7 +- syn/visit/fn.visit_variant.html | 7 +- syn/visit/fn.visit_vis_crate.html | 7 +- syn/visit/fn.visit_vis_public.html | 7 +- syn/visit/fn.visit_vis_restricted.html | 7 +- syn/visit/fn.visit_visibility.html | 7 +- syn/visit/fn.visit_where_clause.html | 7 +- syn/visit/fn.visit_where_predicate.html | 7 +- syn/visit/index.html | 9 +- syn/visit/trait.Visit.html | 9 +- synstructure/all.html | 9 +- synstructure/enum.AddBounds.html | 39 +- synstructure/enum.BindStyle.html | 45 +- synstructure/fn.unpretty_print.html | 9 +- synstructure/index.html | 15 +- synstructure/macro.decl_attribute.html | 9 +- synstructure/macro.decl_derive.html | 9 +- synstructure/macro.test_derive.html | 9 +- synstructure/sidebar-items.js | 2 +- synstructure/struct.BindingInfo.html | 45 +- synstructure/struct.Structure.html | 59 +- synstructure/struct.VariantAst.html | 39 +- synstructure/struct.VariantInfo.html | 41 +- synstructure/trait.MacroResult.html | 11 +- unicode_xid/all.html | 7 +- unicode_xid/constant.UNICODE_VERSION.html | 7 +- unicode_xid/index.html | 7 +- unicode_xid/trait.UnicodeXID.html | 17 +- 650 files changed, 11307 insertions(+), 9843 deletions(-) create mode 100644 FiraSans-Medium.woff2 create mode 100644 FiraSans-Regular.woff2 create mode 100644 crates.js diff --git a/FiraSans-Medium.woff2 b/FiraSans-Medium.woff2 new file mode 100644 index 0000000000000000000000000000000000000000..7a1e5fc548ef28137a32150b6aa50a568cd53d02 GIT binary patch literal 132780 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 U|Bv{{GaLS=zr5yR%fi3_03@G~A^-pY literal 0 HcmV?d00001 diff --git a/FiraSans-Regular.woff2 b/FiraSans-Regular.woff2 new file mode 100644 index 0000000000000000000000000000000000000000..e766e06ccb0d457fcdc8d4428efb796c7772a497 GIT binary patch literal 129188 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

uw_-ccleOTvRKe~q;A@dVCKH_r8Y@YUT; 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%0A8W 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 z?|ji;code,h4>code,h5>code{color:#e6e1cf;}pre>code{color:#e6e1cf;}span code{color:#e6e1cf;}.docblock a>code{color:#39AFD7 !important;}.docblock code,.docblock-short code{background-color:#191f26;}pre{color:#e6e1cf;background-color:#191f26;}.sidebar{background-color:#14191f;}.logo-container.rust-logo>img{filter:drop-shadow(1px 0 0px #fff) drop-shadow(0 1px 0 #fff) drop-shadow(-1px 0 0 #fff) drop-shadow(0 -1px 0 #fff);}*{scrollbar-color:#5c6773 transparent;}.sidebar{scrollbar-color:#5c6773 transparent;}::-webkit-scrollbar-track{background-color:transparent;}::-webkit-scrollbar-thumb{background-color:#5c6773;}.sidebar::-webkit-scrollbar-track{background-color:transparent;}.sidebar::-webkit-scrollbar-thumb{background-color:#5c6773;}.sidebar .current{background-color:transparent;color:#ffb44c;}.source .sidebar{background-color:#0f1419;}.sidebar .location{border-color:#000;background-color:#0f1419;color:#fff;}.sidebar-elems .location{color:#ff7733;}.sidebar-elems .location a{color:#fff;}.sidebar .version{border-bottom-color:#424c57;}.sidebar-title{border-top-color:#5c6773;border-bottom-color:#5c6773;}.block a:hover{background:transparent;color:#ffb44c;}.line-numbers span{color:#5c6773;}.line-numbers .line-highlighted{color:#708090;background-color:rgba(255,236,164,0.06);padding-right:4px;border-right:1px solid #ffb44c;}.docblock h1,.docblock h2,.docblock h3,.docblock h4,.docblock h5{border-bottom-color:#5c6773;}.docblock table,.docblock table td,.docblock table th{border-color:#5c6773;}.content .method .where,.content .fn .where,.content .where.fmt-newline{color:#c5c5c5;}.content .highlighted{color:#000 !important;background-color:#c6afb3;}.content .highlighted a,.content .highlighted span{color:#000 !important;}.content .highlighted{background-color:#c6afb3;}.search-results a{color:#0096cf;}.search-results a span.desc{color:#c5c5c5;}.content .item-info::before{color:#ccc;}.content span.foreigntype,.content a.foreigntype{color:#ef57ff;}.content span.union,.content a.union{color:#98a01c;}.content span.constant,.content a.constant,.content span.static,.content a.static{color:#6380a0;}.content span.primitive,.content a.primitive{color:#32889b;}.content span.traitalias,.content a.traitalias{color:#57d399;}.content span.keyword,.content a.keyword{color:#de5249;}.content span.externcrate,.content span.mod,.content a.mod{color:#acccf9;}.content span.struct,.content a.struct{color:#ffa0a5;}.content span.enum,.content a.enum{color:#99e0c9;}.content span.trait,.content a.trait{color:#39AFD7;}.content span.type,.content a.type{color:#cfbcf5;}.content span.fn,.content a.fn,.content span.method,.content a.method,.content span.tymethod,.content a.tymethod,.content .fnname{color:#fdd687;}.content span.attr,.content a.attr,.content span.derive,.content a.derive,.content span.macro,.content a.macro{color:#a37acc;}pre.rust .comment{color:#788797;}pre.rust .doccomment{color:#a1ac88;}nav:not(.sidebar){border-bottom-color:#424c57;}nav.main .current{border-top-color:#5c6773;border-bottom-color:#5c6773;}nav.main .separator{border:1px solid #5c6773;}a{color:#c5c5c5;}.docblock:not(.type-decl) a:not(.srclink):not(.test-arrow),.docblock-short a:not(.srclink):not(.test-arrow),.item-info a,#help a{color:#39AFD7;}.collapse-toggle{color:#999;}#crate-search{color:#c5c5c5;background-color:#141920;box-shadow:0 0 0 1px #424c57,0 0 0 2px transparent;border-color:#424c57;}.search-input{color:#ffffff;background-color:#141920;box-shadow:0 0 0 1px #424c57,0 0 0 2px transparent;transition:box-shadow 150ms ease-in-out;}#crate-search+.search-input:focus{box-shadow:0 0 0 1px #148099,0 0 0 2px transparent;}.search-focus:disabled{color:#929292;}.module-item .stab{color:#000;}.stab.unstable,.stab.deprecated,.stab.portability{color:#c5c5c5;background:#314559 !important;border-style:none !important;border-radius:4px;padding:3px 6px 3px 6px;}.stab.portability>code{color:#e6e1cf;background-color:transparent;}#help>div{background:#14191f;box-shadow:0px 6px 20px 0px black;border:none;border-radius:4px;}#help>div>span{border-bottom-color:#5c6773;}.since{color:grey;}tr.result span.primitive::after,tr.result span.keyword::after{color:#788797;}.line-numbers :target{background-color:transparent;}pre.rust .number,pre.rust .string{color:#b8cc52;}pre.rust .kw,pre.rust .kw-2,pre.rust .prelude-ty,pre.rust .bool-val,pre.rust .prelude-val,pre.rust .op,pre.rust .lifetime{color:#ff7733;}pre.rust .macro,pre.rust .macro-nonterminal{color:#a37acc;}pre.rust .question-mark{color:#ff9011;}pre.rust .self{color:#36a3d9;font-style:italic;}pre.rust .attribute{color:#e6e1cf;}pre.rust .attribute .ident,pre.rust .attribute .op{color:#e6e1cf;}.example-wrap>pre.line-number{color:#5c67736e;border:none;}a.test-arrow{font-size:100%;color:#788797;border-radius:4px;background-color:rgba(57,175,215,0.09);}a.test-arrow:hover{background-color:rgba(57,175,215,0.368);color:#c5c5c5;}.toggle-label{color:#999;}:target>code,:target>.in-band{background:rgba(255,236,164,0.06);border-right:3px solid rgba(255,180,76,0.85);}pre.compile_fail{border-left:2px solid rgba(255,0,0,.4);}pre.compile_fail:hover,.information:hover+pre.compile_fail{border-left:2px solid #f00;}pre.should_panic{border-left:2px solid rgba(255,0,0,.4);}pre.should_panic:hover,.information:hover+pre.should_panic{border-left:2px solid #f00;}pre.ignore{border-left:2px solid rgba(255,142,0,.6);}pre.ignore:hover,.information:hover+pre.ignore{border-left:2px solid #ff9200;}.tooltip.compile_fail{color:rgba(255,0,0,.5);}.information>.compile_fail:hover{color:#f00;}.tooltip.should_panic{color:rgba(255,0,0,.5);}.information>.should_panic:hover{color:#f00;}.tooltip.ignore{color:rgba(255,142,0,.6);}.information>.ignore:hover{color:#ff9200;}.search-failed a{color:#39AFD7;}.tooltip::after{background-color:#314559;color:#c5c5c5;border:1px solid #5c6773;}.tooltip::before{border-color:transparent #314559 transparent transparent;}.notable-traits-tooltiptext{background-color:#314559;border-color:#5c6773;}#titles>button.selected{background-color:#141920 !important;border-bottom:1px solid #ffb44c !important;border-top:none;}#titles>button:not(.selected){background-color:transparent !important;border:none;}#titles>button:hover{border-bottom:1px solid rgba(242,151,24,0.3);}#titles>button>div.count{color:#888;}.content .highlighted.mod,.content .highlighted.externcrate{}.search-input:focus{}.content span.attr,.content a.attr,.block a.current.attr,.content span.derive,.content a.derive,.block a.current.derive,.content span.macro,.content a.macro,.block a.current.macro{}.content .highlighted.trait{}.content span.struct,.content a.struct,.block a.current.struct{}#titles>button:hover,#titles>button.selected{}.content .highlighted.traitalias{}.content span.type,.content a.type,.block a.current.type{}.content span.union,.content a.union,.block a.current.union{}.content .highlighted.foreigntype{}pre.rust .lifetime{}.content .highlighted.primitive{}.content .highlighted.constant,.content .highlighted.static{}.stab.unstable{}.content .highlighted.fn,.content .highlighted.method,.content .highlighted.tymethod{}h2,h3:not(.impl):not(.method):not(.type):not(.tymethod),h4:not(.method):not(.type):not(.tymethod){}.content span.enum,.content a.enum,.block a.current.enum{}.content span.constant,.content a.constant,.block a.current.constant,.content span.static,.content a.static,.block a.current.static{}.content span.keyword,.content a.keyword,.block a.current.keyword{}pre.rust .comment{}.content .highlighted.enum{}.content .highlighted.struct{}.content .highlighted.keyword{}.content span.traitalias,.content a.traitalias,.block a.current.traitalias{}.content span.fn,.content a.fn,.block a.current.fn,.content span.method,.content a.method,.block a.current.method,.content span.tymethod,.content a.tymethod,.block a.current.tymethod,.content .fnname{}pre.rust .kw{}pre.rust .self,pre.rust .bool-val,pre.rust .prelude-val,pre.rust .attribute,pre.rust .attribute .ident{}.content span.foreigntype,.content a.foreigntype,.block a.current.foreigntype{}pre.rust .doccomment{}.stab.deprecated{}.content .highlighted.attr,.content .highlighted.derive,.content .highlighted.macro{}.stab.portability{}.content .highlighted.union{}.content span.primitive,.content a.primitive,.block a.current.primitive{}.content span.externcrate,.content span.mod,.content a.mod,.block a.current.mod{}.content .highlighted.type{}pre.rust .kw-2,pre.rust .prelude-ty{}.content span.trait,.content a.trait,.block a.current.trait{}@media (max-width:700px){.sidebar-menu{background-color:#14191f;border-bottom-color:#5c6773;border-right-color:#5c6773;}.sidebar-elems{background-color:#14191f;border-right-color:#5c6773;}#sidebar-filler{background-color:#14191f;border-bottom-color:#5c6773;}}kbd{color:#c5c5c5;background-color:#314559;border-color:#5c6773;border-bottom-color:#5c6773;box-shadow-color:#c6cbd1;}#theme-picker,#settings-menu,.help-button{border-color:#5c6773;background-color:#0f1419;color:#fff;}#theme-picker>img,#settings-menu>img{filter:invert(100);}#theme-picker:hover,#theme-picker:focus,#settings-menu:hover,#settings-menu:focus,.help-button:hover,.help-button:focus{border-color:#e0e0e0;}#theme-choices{border-color:#5c6773;background-color:#0f1419;}#theme-choices>button:not(:first-child){border-top-color:#5c6773;}#theme-choices>button:hover,#theme-choices>button:focus{background-color:rgba(110,110,110,0.33);}@media (max-width:700px){#theme-picker{background:#0f1419;}}#all-types{background-color:#14191f;}#all-types:hover{background-color:rgba(70,70,70,0.33);}.search-results td span.alias{color:#c5c5c5;}.search-results td span.grey{color:#999;}#sidebar-toggle{background-color:#14191f;}#sidebar-toggle:hover{background-color:rgba(70,70,70,0.33);}#source-sidebar{background-color:#14191f;}#source-sidebar>.title{color:#fff;border-bottom-color:#5c6773;}div.files>a:hover,div.name:hover{background-color:#14191f;color:#ffb44c;}div.files>.selected{background-color:#14191f;color:#ffb44c;}.setting-line>.title{border-bottom-color:#5c6773;}input:checked+.slider{background-color:#ffb454 !important;} \ No newline at end of file + body{background-color:#0f1419;color:#c5c5c5;}h1,h2,h3:not(.impl):not(.method):not(.type):not(.tymethod),h4:not(.method):not(.type):not(.tymethod){color:white;}h1.fqn{border-bottom-color:#5c6773;}h1.fqn a{color:#fff;}h2,h3:not(.impl):not(.method):not(.type):not(.tymethod){border-bottom-color:#5c6773;}h4:not(.method):not(.type):not(.tymethod):not(.associatedconstant){border:none;}.in-band{background-color:#0f1419;}.invisible{background:rgba(0,0,0,0);}code{color:#ffb454;}h3>code,h4>code,h5>code{color:#e6e1cf;}pre>code{color:#e6e1cf;}span code{color:#e6e1cf;}.docblock a>code{color:#39AFD7 !important;}.docblock code,.docblock-short code{background-color:#191f26;}pre{color:#e6e1cf;background-color:#191f26;}.sidebar{background-color:#14191f;}.logo-container.rust-logo>img{filter:drop-shadow(1px 0 0px #fff) drop-shadow(0 1px 0 #fff) drop-shadow(-1px 0 0 #fff) drop-shadow(0 -1px 0 #fff);}*{scrollbar-color:#5c6773 transparent;}.sidebar{scrollbar-color:#5c6773 transparent;}::-webkit-scrollbar-track{background-color:transparent;}::-webkit-scrollbar-thumb{background-color:#5c6773;}.sidebar::-webkit-scrollbar-track{background-color:transparent;}.sidebar::-webkit-scrollbar-thumb{background-color:#5c6773;}.sidebar .current{background-color:transparent;color:#ffb44c;}.source .sidebar{background-color:#0f1419;}.sidebar .location{border-color:#000;background-color:#0f1419;color:#fff;}.sidebar-elems .location{color:#ff7733;}.sidebar-elems .location a{color:#fff;}.sidebar .version{border-bottom-color:#424c57;}.sidebar-title{border-top-color:#5c6773;border-bottom-color:#5c6773;}.block a:hover{background:transparent;color:#ffb44c;}.line-numbers span{color:#5c6773;}.line-numbers .line-highlighted{color:#708090;background-color:rgba(255,236,164,0.06);padding-right:4px;border-right:1px solid #ffb44c;}.docblock h1,.docblock h2,.docblock h3,.docblock h4,.docblock h5{border-bottom-color:#5c6773;}.docblock table,.docblock table td,.docblock table th{border-color:#5c6773;}.content .method .where,.content .fn .where,.content .where.fmt-newline{color:#c5c5c5;}.content .highlighted{color:#000 !important;background-color:#c6afb3;}.content .highlighted a,.content .highlighted span{color:#000 !important;}.content .highlighted{background-color:#c6afb3;}.search-results a{color:#0096cf;}.search-results a span.desc{color:#c5c5c5;}.content .item-info::before{color:#ccc;}.content span.foreigntype,.content a.foreigntype{color:#ef57ff;}.content span.union,.content a.union{color:#98a01c;}.content span.constant,.content a.constant,.content span.static,.content a.static{color:#6380a0;}.content span.primitive,.content a.primitive{color:#32889b;}.content span.traitalias,.content a.traitalias{color:#57d399;}.content span.keyword,.content a.keyword{color:#de5249;}.content span.externcrate,.content span.mod,.content a.mod{color:#acccf9;}.content span.struct,.content a.struct{color:#ffa0a5;}.content span.enum,.content a.enum{color:#99e0c9;}.content span.trait,.content a.trait{color:#39AFD7;}.content span.type,.content a.type{color:#cfbcf5;}.content span.fn,.content a.fn,.content span.method,.content a.method,.content span.tymethod,.content a.tymethod,.content .fnname{color:#fdd687;}.content span.attr,.content a.attr,.content span.derive,.content a.derive,.content span.macro,.content a.macro{color:#a37acc;}pre.rust .comment{color:#788797;}pre.rust .doccomment{color:#a1ac88;}nav:not(.sidebar){border-bottom-color:#424c57;}nav.main .current{border-top-color:#5c6773;border-bottom-color:#5c6773;}nav.main .separator{border:1px solid #5c6773;}a{color:#c5c5c5;}.docblock:not(.type-decl) a:not(.srclink):not(.test-arrow),.docblock-short a:not(.srclink):not(.test-arrow),.item-info a,#help a{color:#39AFD7;}.collapse-toggle{color:#999;}#crate-search{color:#c5c5c5;background-color:#141920;box-shadow:0 0 0 1px #424c57,0 0 0 2px transparent;border-color:#424c57;}.search-input{color:#ffffff;background-color:#141920;box-shadow:0 0 0 1px #424c57,0 0 0 2px transparent;transition:box-shadow 150ms ease-in-out;}#crate-search+.search-input:focus{box-shadow:0 0 0 1px #148099,0 0 0 2px transparent;}.search-focus:disabled{color:#929292;}.module-item .stab{color:#000;}.stab.unstable,.stab.deprecated,.stab.portability{color:#c5c5c5;background:#314559 !important;border-style:none !important;border-radius:4px;padding:3px 6px 3px 6px;}.stab.portability>code{color:#e6e1cf;background:none;}#help>div{background:#14191f;box-shadow:0px 6px 20px 0px black;border:none;border-radius:4px;}#help>div>span{border-bottom-color:#5c6773;}.since{color:grey;}tr.result span.primitive::after,tr.result span.keyword::after{color:#788797;}.line-numbers :target{background-color:transparent;}pre.rust .number,pre.rust .string{color:#b8cc52;}pre.rust .kw,pre.rust .kw-2,pre.rust .prelude-ty,pre.rust .bool-val,pre.rust .prelude-val,pre.rust .op,pre.rust .lifetime{color:#ff7733;}pre.rust .macro,pre.rust .macro-nonterminal{color:#a37acc;}pre.rust .question-mark{color:#ff9011;}pre.rust .self{color:#36a3d9;font-style:italic;}pre.rust .attribute{color:#e6e1cf;}pre.rust .attribute .ident,pre.rust .attribute .op{color:#e6e1cf;}.example-wrap>pre.line-number{color:#5c67736e;border:none;}a.test-arrow{font-size:100%;color:#788797;border-radius:4px;background-color:rgba(57,175,215,0.09);}a.test-arrow:hover{background-color:rgba(57,175,215,0.368);color:#c5c5c5;}.toggle-label{color:#999;}:target>code,:target>.in-band{background:rgba(255,236,164,0.06);border-right:3px solid rgba(255,180,76,0.85);}pre.compile_fail{border-left:2px solid rgba(255,0,0,.4);}pre.compile_fail:hover,.information:hover+pre.compile_fail{border-left:2px solid #f00;}pre.should_panic{border-left:2px solid rgba(255,0,0,.4);}pre.should_panic:hover,.information:hover+pre.should_panic{border-left:2px solid #f00;}pre.ignore{border-left:2px solid rgba(255,142,0,.6);}pre.ignore:hover,.information:hover+pre.ignore{border-left:2px solid #ff9200;}.tooltip.compile_fail{color:rgba(255,0,0,.5);}.information>.compile_fail:hover{color:#f00;}.tooltip.should_panic{color:rgba(255,0,0,.5);}.information>.should_panic:hover{color:#f00;}.tooltip.ignore{color:rgba(255,142,0,.6);}.information>.ignore:hover{color:#ff9200;}.search-failed a{color:#39AFD7;}.tooltip::after{background-color:#314559;color:#c5c5c5;border:1px solid #5c6773;}.tooltip::before{border-color:transparent #314559 transparent transparent;}.notable-traits-tooltiptext{background-color:#314559;border-color:#5c6773;}#titles>button.selected{background-color:#141920 !important;border-bottom:1px solid #ffb44c !important;border-top:none;}#titles>button:not(.selected){background-color:transparent !important;border:none;}#titles>button:hover{border-bottom:1px solid rgba(242,151,24,0.3);}#titles>button>div.count{color:#888;}.content .highlighted.mod,.content .highlighted.externcrate{}.search-input:focus{}.content span.attr,.content a.attr,.block a.current.attr,.content span.derive,.content a.derive,.block a.current.derive,.content span.macro,.content a.macro,.block a.current.macro{}.content .highlighted.trait{}.content span.struct,.content a.struct,.block a.current.struct{}#titles>button:hover,#titles>button.selected{}.content .highlighted.traitalias{}.content span.type,.content a.type,.block a.current.type{}.content span.union,.content a.union,.block a.current.union{}.content .highlighted.foreigntype{}pre.rust .lifetime{}.content .highlighted.primitive{}.content .highlighted.constant,.content .highlighted.static{}.stab.unstable{}.content .highlighted.fn,.content .highlighted.method,.content .highlighted.tymethod{}h2,h3:not(.impl):not(.method):not(.type):not(.tymethod),h4:not(.method):not(.type):not(.tymethod){}.content span.enum,.content a.enum,.block a.current.enum{}.content span.constant,.content a.constant,.block a.current.constant,.content span.static,.content a.static,.block a.current.static{}.content span.keyword,.content a.keyword,.block a.current.keyword{}pre.rust .comment{}.content .highlighted.enum{}.content .highlighted.struct{}.content .highlighted.keyword{}.content span.traitalias,.content a.traitalias,.block a.current.traitalias{}.content span.fn,.content a.fn,.block a.current.fn,.content span.method,.content a.method,.block a.current.method,.content span.tymethod,.content a.tymethod,.block a.current.tymethod,.content .fnname{}pre.rust .kw{}pre.rust .self,pre.rust .bool-val,pre.rust .prelude-val,pre.rust .attribute,pre.rust .attribute .ident{}.content span.foreigntype,.content a.foreigntype,.block a.current.foreigntype{}pre.rust .doccomment{}.stab.deprecated{}.content .highlighted.attr,.content .highlighted.derive,.content .highlighted.macro{}.stab.portability{}.content .highlighted.union{}.content span.primitive,.content a.primitive,.block a.current.primitive{}.content span.externcrate,.content span.mod,.content a.mod,.block a.current.mod{}.content .highlighted.type{}pre.rust .kw-2,pre.rust .prelude-ty{}.content span.trait,.content a.trait,.block a.current.trait{}@media (max-width:700px){.sidebar-menu{background-color:#14191f;border-bottom-color:#5c6773;border-right-color:#5c6773;}.sidebar-elems{background-color:#14191f;border-right-color:#5c6773;}#sidebar-filler{background-color:#14191f;border-bottom-color:#5c6773;}}kbd{color:#c5c5c5;background-color:#314559;border-color:#5c6773;border-bottom-color:#5c6773;box-shadow-color:#c6cbd1;}#theme-picker,#settings-menu,.help-button{border-color:#5c6773;background-color:#0f1419;color:#fff;}#theme-picker>img,#settings-menu>img{filter:invert(100);}#theme-picker:hover,#theme-picker:focus,#settings-menu:hover,#settings-menu:focus,.help-button:hover,.help-button:focus{border-color:#e0e0e0;}#theme-choices{border-color:#5c6773;background-color:#0f1419;}#theme-choices>button:not(:first-child){border-top-color:#5c6773;}#theme-choices>button:hover,#theme-choices>button:focus{background-color:rgba(110,110,110,0.33);}@media (max-width:700px){#theme-picker{background:#0f1419;}}#all-types{background-color:#14191f;}#all-types:hover{background-color:rgba(70,70,70,0.33);}.search-results td span.alias{color:#c5c5c5;}.search-results td span.grey{color:#999;}#sidebar-toggle{background-color:#14191f;}#sidebar-toggle:hover{background-color:rgba(70,70,70,0.33);}#source-sidebar{background-color:#14191f;}#source-sidebar>.title{color:#fff;border-bottom-color:#5c6773;}div.files>a:hover,div.name:hover{background-color:#14191f;color:#ffb44c;}div.files>.selected{background-color:#14191f;color:#ffb44c;}.setting-line>.title{border-bottom-color:#5c6773;}input:checked+.slider{background-color:#ffb454 !important;} \ No newline at end of file diff --git a/cfg_if/all.html b/cfg_if/all.html index fb218fa..bee8dba 100644 --- a/cfg_if/all.html +++ b/cfg_if/all.html @@ -1,6 +1,7 @@ -List of all items in this crate +List of all items in this crate -

[−] +

List of all items[−] - List of all items

Macros

\ No newline at end of file +

Macros

+ \ No newline at end of file diff --git a/cfg_if/index.html b/cfg_if/index.html index 3ec7309..ce85bfd 100644 --- a/cfg_if/index.html +++ b/cfg_if/index.html @@ -1,11 +1,11 @@ -cfg_if - Rust +cfg_if - Rust -

[−][src]Crate cfg_if

A macro for defining #[cfg] if-else statements.

+

Crate cfg_if[−][src]

A macro for defining #[cfg] if-else statements.

The macro provided by this crate, cfg_if, is similar to the if/elif C preprocessor macro by allowing definition of a cascade of #[cfg] cases, emitting the implementation which matches first.

-

This allows you to conveniently provide a long list #[cfg]'d blocks of code +

This allows you to conveniently provide a long list #[cfg]’d blocks of code without having to rewrite each clause multiple times.

Example

@@ -22,4 +22,5 @@ without having to rewrite each clause multiple times.

Macros

cfg_if

The main macro provided by this crate. See crate documentation for more information.

-
\ No newline at end of file +
+ \ No newline at end of file diff --git a/cfg_if/macro.cfg_if.html b/cfg_if/macro.cfg_if.html index cbde7d5..fe8fa75 100644 --- a/cfg_if/macro.cfg_if.html +++ b/cfg_if/macro.cfg_if.html @@ -1,7 +1,7 @@ -cfg_if::cfg_if - Rust +cfg_if::cfg_if - Rust -

[−][src]Macro cfg_if::cfg_if

+
Macro cfg_if::cfg_if[−][src]
 macro_rules! cfg_if {
     ($(
         if #[cfg($meta:meta)] { $($tokens:tt)* }
@@ -20,4 +20,5 @@
 }

 
The main macro provided by this crate. See crate documentation for more
 information.

-

\ No newline at end of file
+
+ \ No newline at end of file diff --git a/crates.js b/crates.js new file mode 100644 index 0000000..13f3aaa --- /dev/null +++ b/crates.js @@ -0,0 +1 @@ +window.ALL_CRATES = ["cfg_if","delog","flexiber","flexiber_derive","log","proc_macro2","quote","syn","synstructure","unicode_xid"]; \ No newline at end of file diff --git a/dark.css b/dark.css index 85dec48..8ee9c65 100644 --- a/dark.css +++ b/dark.css @@ -1 +1 @@ -body{background-color:#353535;color:#ddd;}h1,h2,h3:not(.impl):not(.method):not(.type):not(.tymethod),h4:not(.method):not(.type):not(.tymethod){color:#ddd;}h1.fqn{border-bottom-color:#d2d2d2;}h2,h3:not(.impl):not(.method):not(.type):not(.tymethod),h4:not(.method):not(.type):not(.tymethod){border-bottom-color:#d2d2d2;}.in-band{background-color:#353535;}.invisible{background:rgba(0,0,0,0);}.docblock code,.docblock-short code{background-color:#2A2A2A;}pre{background-color:#2A2A2A;}.sidebar{background-color:#505050;}.logo-container.rust-logo>img{filter:drop-shadow(1px 0 0px #fff) drop-shadow(0 1px 0 #fff) drop-shadow(-1px 0 0 #fff) drop-shadow(0 -1px 0 #fff)}*{scrollbar-color:rgb(64,65,67) #717171;}.sidebar{scrollbar-color:rgba(32,34,37,.6) transparent;}::-webkit-scrollbar-track{background-color:#717171;}::-webkit-scrollbar-thumb{background-color:rgba(32,34,37,.6);}.sidebar::-webkit-scrollbar-track{background-color:#717171;}.sidebar::-webkit-scrollbar-thumb{background-color:rgba(32,34,37,.6);}.sidebar .current{background-color:#333;}.source .sidebar{background-color:#353535;}.sidebar .location{border-color:#fff;background:#575757;color:#DDD;}.sidebar .version{border-bottom-color:#DDD;}.sidebar-title{border-top-color:#777;border-bottom-color:#777;}.block a:hover{background:#444;}.line-numbers span{color:#3B91E2;}.line-numbers .line-highlighted{background-color:#0a042f !important;}.docblock h1,.docblock h2,.docblock h3,.docblock h4,.docblock h5{border-bottom-color:#DDD;}.docblock table,.docblock table td,.docblock table th{border-color:#ddd;}.content .method .where,.content .fn .where,.content .where.fmt-newline{color:#ddd;}.content .highlighted{color:#eee !important;background-color:#616161;}.content .highlighted a,.content .highlighted span{color:#eee !important;}.content .highlighted.trait{background-color:#013191;}.content .highlighted.traitalias{background-color:#013191;}.content .highlighted.mod,.content .highlighted.externcrate{background-color:#afc6e4;}.content .highlighted.mod{background-color:#803a1b;}.content .highlighted.externcrate{background-color:#396bac;}.content .highlighted.enum{background-color:#5b4e68;}.content .highlighted.struct{background-color:#194e9f;}.content .highlighted.union{background-color:#b7bd49;}.content .highlighted.fn,.content .highlighted.method,.content .highlighted.tymethod{background-color:#4950ed;}.content .highlighted.type{background-color:#38902c;}.content .highlighted.foreigntype{background-color:#b200d6;}.content .highlighted.attr,.content .highlighted.derive,.content .highlighted.macro{background-color:#217d1c;}.content .highlighted.constant,.content .highlighted.static{background-color:#0063cc;}.content .highlighted.primitive{background-color:#00708a;}.content .highlighted.keyword{background-color:#884719;}.content .item-info::before{color:#ccc;}.content span.enum,.content a.enum,.block a.current.enum{color:#82b089;}.content span.struct,.content a.struct,.block a.current.struct{color:#2dbfb8;}.content span.type,.content a.type,.block a.current.type{color:#ff7f00;}.content span.foreigntype,.content a.foreigntype,.block a.current.foreigntype{color:#dd7de8;}.content span.attr,.content a.attr,.block a.current.attr,.content span.derive,.content a.derive,.block a.current.derive,.content span.macro,.content a.macro,.block a.current.macro{color:#09bd00;}.content span.union,.content a.union,.block a.current.union{color:#a6ae37;}.content span.constant,.content a.constant,.block a.current.constant,.content span.static,.content a.static,.block a.current.static{color:#82a5c9;}.content span.primitive,.content a.primitive,.block a.current.primitive{color:#43aec7;}.content span.externcrate,.content span.mod,.content a.mod,.block a.current.mod{color:#bda000;}.content span.trait,.content a.trait,.block a.current.trait{color:#b78cf2;}.content span.traitalias,.content a.traitalias,.block a.current.traitalias{color:#b397da;}.content span.fn,.content a.fn,.block a.current.fn,.content span.method,.content a.method,.block a.current.method,.content span.tymethod,.content a.tymethod,.block a.current.tymethod,.content .fnname{color:#2BAB63;}.content span.keyword,.content a.keyword,.block a.current.keyword{color:#de5249;}pre.rust .comment{color:#8d8d8b;}pre.rust .doccomment{color:#8ca375;}nav:not(.sidebar){border-bottom-color:#4e4e4e;}nav.main .current{border-top-color:#eee;border-bottom-color:#eee;}nav.main .separator{border-color:#eee;}a{color:#ddd;}.docblock:not(.type-decl) a:not(.srclink):not(.test-arrow),.docblock-short a:not(.srclink):not(.test-arrow),.item-info a,#help a{color:#D2991D;}a.test-arrow{color:#dedede;}.collapse-toggle{color:#999;}#crate-search{color:#111;background-color:#f0f0f0;border-color:#000;box-shadow:0 0 0 1px #000,0 0 0 2px transparent;}.search-input{color:#111;background-color:#f0f0f0;box-shadow:0 0 0 1px #000,0 0 0 2px transparent;}.search-input:focus{border-color:#008dfd;}.search-focus:disabled{background-color:#c5c4c4;}#crate-search+.search-input:focus{box-shadow:0 0 8px 4px #078dd8;}.module-item .stab{color:#ddd;}.stab.unstable{background:#FFF5D6;border-color:#FFC600;color:#2f2f2f;}.stab.deprecated{background:#F3DFFF;border-color:#7F0087;color:#2f2f2f;}.stab.portability{background:#C4ECFF;border-color:#7BA5DB;color:#2f2f2f;}.stab.portability>code{color:#ddd;}#help>div{background:#4d4d4d;border-color:#bfbfbf;}#help>div>span{border-bottom-color:#bfbfbf;}#help dt{border-color:#bfbfbf;background:rgba(0,0,0,0);color:black;}.since{color:grey;}tr.result span.primitive::after,tr.result span.keyword::after{color:#ddd;}.line-numbers :target{background-color:transparent;}pre.rust .kw{color:#ab8ac1;}pre.rust .kw-2,pre.rust .prelude-ty{color:#769acb;}pre.rust .number,pre.rust .string{color:#83a300;}pre.rust .self,pre.rust .bool-val,pre.rust .prelude-val,pre.rust .attribute,pre.rust .attribute .ident{color:#ee6868;}pre.rust .macro,pre.rust .macro-nonterminal{color:#3E999F;}pre.rust .lifetime{color:#d97f26;}pre.rust .question-mark{color:#ff9011;}.example-wrap>pre.line-number{border-color:#4a4949;}a.test-arrow{background-color:rgba(78,139,202,0.2);}a.test-arrow:hover{background-color:#4e8bca;}.toggle-label{color:#999;}:target>code,:target>.in-band{background-color:#494a3d;border-right:3px solid #bb7410;}pre.compile_fail{border-left:2px solid rgba(255,0,0,.8);}pre.compile_fail:hover,.information:hover+pre.compile_fail{border-left:2px solid #f00;}pre.should_panic{border-left:2px solid rgba(255,0,0,.8);}pre.should_panic:hover,.information:hover+pre.should_panic{border-left:2px solid #f00;}pre.ignore{border-left:2px solid rgba(255,142,0,.6);}pre.ignore:hover,.information:hover+pre.ignore{border-left:2px solid #ff9200;}.tooltip.compile_fail{color:rgba(255,0,0,.8);}.information>.compile_fail:hover{color:#f00;}.tooltip.should_panic{color:rgba(255,0,0,.8);}.information>.should_panic:hover{color:#f00;}.tooltip.ignore{color:rgba(255,142,0,.6);}.information>.ignore:hover{color:#ff9200;}.search-failed a{color:#0089ff;}.tooltip::after{background-color:#000;color:#fff;border-color:#000;}.tooltip::before{border-color:transparent black transparent transparent;}.notable-traits-tooltiptext{background-color:#111;border-color:#777;}#titles>button:not(.selected){background-color:#252525;border-top-color:#252525;}#titles>button:hover,#titles>button.selected{border-top-color:#0089ff;background-color:#353535;}#titles>button>div.count{color:#888;}@media (max-width:700px){.sidebar-menu{background-color:#505050;border-bottom-color:#e0e0e0;border-right-color:#e0e0e0;}.sidebar-elems{background-color:#505050;border-right-color:#000;}#sidebar-filler{background-color:#505050;border-bottom-color:#e0e0e0;}}kbd{color:#000;background-color:#fafbfc;border-color:#d1d5da;border-bottom-color:#c6cbd1;box-shadow-color:#c6cbd1;}#theme-picker,#settings-menu,.help-button{border-color:#e0e0e0;background:#f0f0f0;color:#000;}#theme-picker:hover,#theme-picker:focus,#settings-menu:hover,#settings-menu:focus,.help-button:hover,.help-button:focus{border-color:#ffb900;}#theme-choices{border-color:#e0e0e0;background-color:#353535;}#theme-choices>button:not(:first-child){border-top-color:#e0e0e0;}#theme-choices>button:hover,#theme-choices>button:focus{background-color:#4e4e4e;}@media (max-width:700px){#theme-picker{background:#f0f0f0;}}#all-types{background-color:#505050;}#all-types:hover{background-color:#606060;}.search-results td span.alias{color:#fff;}.search-results td span.grey{color:#ccc;}#sidebar-toggle{background-color:#565656;}#sidebar-toggle:hover{background-color:#676767;}#source-sidebar{background-color:#565656;}#source-sidebar>.title{border-bottom-color:#ccc;}div.files>a:hover,div.name:hover{background-color:#444;}div.files>.selected{background-color:#333;}.setting-line>.title{border-bottom-color:#ddd;} \ No newline at end of file +body{background-color:#353535;color:#ddd;}h1,h2,h3:not(.impl):not(.method):not(.type):not(.tymethod),h4:not(.method):not(.type):not(.tymethod){color:#ddd;}h1.fqn{border-bottom-color:#d2d2d2;}h2,h3:not(.impl):not(.method):not(.type):not(.tymethod),h4:not(.method):not(.type):not(.tymethod){border-bottom-color:#d2d2d2;}.in-band{background-color:#353535;}.invisible{background:rgba(0,0,0,0);}.docblock code,.docblock-short code{background-color:#2A2A2A;}pre{background-color:#2A2A2A;}.sidebar{background-color:#505050;}.logo-container.rust-logo>img{filter:drop-shadow(1px 0 0px #fff) drop-shadow(0 1px 0 #fff) drop-shadow(-1px 0 0 #fff) drop-shadow(0 -1px 0 #fff)}*{scrollbar-color:rgb(64,65,67) #717171;}.sidebar{scrollbar-color:rgba(32,34,37,.6) transparent;}::-webkit-scrollbar-track{background-color:#717171;}::-webkit-scrollbar-thumb{background-color:rgba(32,34,37,.6);}.sidebar::-webkit-scrollbar-track{background-color:#717171;}.sidebar::-webkit-scrollbar-thumb{background-color:rgba(32,34,37,.6);}.sidebar .current{background-color:#333;}.source .sidebar{background-color:#353535;}.sidebar .location{border-color:#fff;background:#575757;color:#DDD;}.sidebar .version{border-bottom-color:#DDD;}.sidebar-title{border-top-color:#777;border-bottom-color:#777;}.block a:hover{background:#444;}.line-numbers span{color:#3B91E2;}.line-numbers .line-highlighted{background-color:#0a042f !important;}.docblock h1,.docblock h2,.docblock h3,.docblock h4,.docblock h5{border-bottom-color:#DDD;}.docblock table,.docblock table td,.docblock table th{border-color:#ddd;}.content .method .where,.content .fn .where,.content .where.fmt-newline{color:#ddd;}.content .highlighted{color:#eee !important;background-color:#616161;}.content .highlighted a,.content .highlighted span{color:#eee !important;}.content .highlighted.trait{background-color:#013191;}.content .highlighted.traitalias{background-color:#013191;}.content .highlighted.mod,.content .highlighted.externcrate{background-color:#afc6e4;}.content .highlighted.mod{background-color:#803a1b;}.content .highlighted.externcrate{background-color:#396bac;}.content .highlighted.enum{background-color:#5b4e68;}.content .highlighted.struct{background-color:#194e9f;}.content .highlighted.union{background-color:#b7bd49;}.content .highlighted.fn,.content .highlighted.method,.content .highlighted.tymethod{background-color:#4950ed;}.content .highlighted.type{background-color:#38902c;}.content .highlighted.foreigntype{background-color:#b200d6;}.content .highlighted.attr,.content .highlighted.derive,.content .highlighted.macro{background-color:#217d1c;}.content .highlighted.constant,.content .highlighted.static{background-color:#0063cc;}.content .highlighted.primitive{background-color:#00708a;}.content .highlighted.keyword{background-color:#884719;}.content .item-info::before{color:#ccc;}.content span.enum,.content a.enum,.block a.current.enum{color:#82b089;}.content span.struct,.content a.struct,.block a.current.struct{color:#2dbfb8;}.content span.type,.content a.type,.block a.current.type{color:#ff7f00;}.content span.foreigntype,.content a.foreigntype,.block a.current.foreigntype{color:#dd7de8;}.content span.attr,.content a.attr,.block a.current.attr,.content span.derive,.content a.derive,.block a.current.derive,.content span.macro,.content a.macro,.block a.current.macro{color:#09bd00;}.content span.union,.content a.union,.block a.current.union{color:#a6ae37;}.content span.constant,.content a.constant,.block a.current.constant,.content span.static,.content a.static,.block a.current.static{color:#82a5c9;}.content span.primitive,.content a.primitive,.block a.current.primitive{color:#43aec7;}.content span.externcrate,.content span.mod,.content a.mod,.block a.current.mod{color:#bda000;}.content span.trait,.content a.trait,.block a.current.trait{color:#b78cf2;}.content span.traitalias,.content a.traitalias,.block a.current.traitalias{color:#b397da;}.content span.fn,.content a.fn,.block a.current.fn,.content span.method,.content a.method,.block a.current.method,.content span.tymethod,.content a.tymethod,.block a.current.tymethod,.content .fnname{color:#2BAB63;}.content span.keyword,.content a.keyword,.block a.current.keyword{color:#de5249;}pre.rust .comment{color:#8d8d8b;}pre.rust .doccomment{color:#8ca375;}nav:not(.sidebar){border-bottom-color:#4e4e4e;}nav.main .current{border-top-color:#eee;border-bottom-color:#eee;}nav.main .separator{border-color:#eee;}a{color:#ddd;}.docblock:not(.type-decl) a:not(.srclink):not(.test-arrow),.docblock-short a:not(.srclink):not(.test-arrow),.item-info a,#help a{color:#D2991D;}a.test-arrow{color:#dedede;}.collapse-toggle{color:#999;}#crate-search{color:#111;background-color:#f0f0f0;border-color:#000;box-shadow:0 0 0 1px #000,0 0 0 2px transparent;}.search-input{color:#111;background-color:#f0f0f0;box-shadow:0 0 0 1px #000,0 0 0 2px transparent;}.search-input:focus{border-color:#008dfd;}.search-focus:disabled{background-color:#c5c4c4;}#crate-search+.search-input:focus{box-shadow:0 0 8px 4px #078dd8;}.module-item .stab{color:#ddd;}.stab.unstable{background:#FFF5D6;border-color:#FFC600;color:#2f2f2f;}.stab.deprecated{background:#F3DFFF;border-color:#7F0087;color:#2f2f2f;}.stab.portability{background:#C4ECFF;border-color:#7BA5DB;color:#2f2f2f;}.stab.portability>code{background:none;}#help>div{background:#4d4d4d;border-color:#bfbfbf;}#help>div>span{border-bottom-color:#bfbfbf;}#help dt{border-color:#bfbfbf;background:rgba(0,0,0,0);}.since{color:grey;}tr.result span.primitive::after,tr.result span.keyword::after{color:#ddd;}.line-numbers :target{background-color:transparent;}pre.rust .kw{color:#ab8ac1;}pre.rust .kw-2,pre.rust .prelude-ty{color:#769acb;}pre.rust .number,pre.rust .string{color:#83a300;}pre.rust .self,pre.rust .bool-val,pre.rust .prelude-val,pre.rust .attribute,pre.rust .attribute .ident{color:#ee6868;}pre.rust .macro,pre.rust .macro-nonterminal{color:#3E999F;}pre.rust .lifetime{color:#d97f26;}pre.rust .question-mark{color:#ff9011;}.example-wrap>pre.line-number{border-color:#4a4949;}a.test-arrow{background-color:rgba(78,139,202,0.2);}a.test-arrow:hover{background-color:#4e8bca;}.toggle-label{color:#999;}:target>code,:target>.in-band{background-color:#494a3d;border-right:3px solid #bb7410;}pre.compile_fail{border-left:2px solid rgba(255,0,0,.8);}pre.compile_fail:hover,.information:hover+pre.compile_fail{border-left:2px solid #f00;}pre.should_panic{border-left:2px solid rgba(255,0,0,.8);}pre.should_panic:hover,.information:hover+pre.should_panic{border-left:2px solid #f00;}pre.ignore{border-left:2px solid rgba(255,142,0,.6);}pre.ignore:hover,.information:hover+pre.ignore{border-left:2px solid #ff9200;}.tooltip.compile_fail{color:rgba(255,0,0,.8);}.information>.compile_fail:hover{color:#f00;}.tooltip.should_panic{color:rgba(255,0,0,.8);}.information>.should_panic:hover{color:#f00;}.tooltip.ignore{color:rgba(255,142,0,.6);}.information>.ignore:hover{color:#ff9200;}.search-failed a{color:#0089ff;}.tooltip::after{background-color:#000;color:#fff;border-color:#000;}.tooltip::before{border-color:transparent black transparent transparent;}.notable-traits-tooltiptext{background-color:#111;border-color:#777;}#titles>button:not(.selected){background-color:#252525;border-top-color:#252525;}#titles>button:hover,#titles>button.selected{border-top-color:#0089ff;background-color:#353535;}#titles>button>div.count{color:#888;}@media (max-width:700px){.sidebar-menu{background-color:#505050;border-bottom-color:#e0e0e0;border-right-color:#e0e0e0;}.sidebar-elems{background-color:#505050;border-right-color:#000;}#sidebar-filler{background-color:#505050;border-bottom-color:#e0e0e0;}}kbd{color:#000;background-color:#fafbfc;border-color:#d1d5da;border-bottom-color:#c6cbd1;box-shadow-color:#c6cbd1;}#theme-picker,#settings-menu,.help-button{border-color:#e0e0e0;background:#f0f0f0;color:#000;}#theme-picker:hover,#theme-picker:focus,#settings-menu:hover,#settings-menu:focus,.help-button:hover,.help-button:focus{border-color:#ffb900;}#theme-choices{border-color:#e0e0e0;background-color:#353535;}#theme-choices>button:not(:first-child){border-top-color:#e0e0e0;}#theme-choices>button:hover,#theme-choices>button:focus{background-color:#4e4e4e;}@media (max-width:700px){#theme-picker{background:#f0f0f0;}}#all-types{background-color:#505050;}#all-types:hover{background-color:#606060;}.search-results td span.alias{color:#fff;}.search-results td span.grey{color:#ccc;}#sidebar-toggle{background-color:#565656;}#sidebar-toggle:hover{background-color:#676767;}#source-sidebar{background-color:#565656;}#source-sidebar>.title{border-bottom-color:#ccc;}div.files>a:hover,div.name:hover{background-color:#444;}div.files>.selected{background-color:#333;}.setting-line>.title{border-bottom-color:#ddd;} \ No newline at end of file diff --git a/delog/all.html b/delog/all.html index 89a47a6..a62c087 100644 --- a/delog/all.html +++ b/delog/all.html @@ -1,6 +1,7 @@ -List of all items in this crate +List of all items in this crate -

[−] +

List of all items[−] - List of all items

Structs

Enums

Traits

Macros

Functions

\ No newline at end of file +

Structs

Enums

Traits

Macros

Functions

+ \ No newline at end of file diff --git a/delog/enum.Level.html b/delog/enum.Level.html index 8f5c2ba..31f0fba 100644 --- a/delog/enum.Level.html +++ b/delog/enum.Level.html @@ -1,7 +1,7 @@ -delog::Level - Rust +delog::Level - Rust -

[−][src]Enum delog::Level

#[repr(usize)]pub enum Level {
+
Enum delog::Level[−][src]
#[repr(usize)]pub enum Level {
     Error,
     Warn,
     Info,
@@ -14,69 +14,70 @@
 LevelFilter.

 

                    Variants

-
Error
The "error" level.

+
Error
The “error” level.

 
Designates very serious errors.

-
Warn
The "warn" level.

+
Warn
The “warn” level.

 
Designates hazardous situations.

-
Info
The "info" level.

+
Info
The “info” level.

 
Designates useful information.

-
Debug
The "debug" level.

+
Debug
The “debug” level.

 
Designates lower priority information.

-
Trace
The "trace" level.

+
Trace
The “trace” level.

 
Designates very low priority, often extremely verbose, information.

-
Implementations
impl Level[src]
pub fn max() -> Level[src]
Returns the most verbose logging level.

-
pub fn to_level_filter(&self) -> LevelFilter[src]
Converts the Level to the equivalent LevelFilter.

-
pub fn as_str(&self) -> &'static str[src]
Returns the string representation of the Level.

+
Implementations
impl Level[src]
pub fn max() -> Level[src]
Returns the most verbose logging level.

+
pub fn to_level_filter(&self) -> LevelFilter[src]
Converts the Level to the equivalent LevelFilter.

+
pub fn as_str(&self) -> &'static str[src]
Returns the string representation of the Level.

 
This returns the same string as the fmt::Display implementation.

-
Trait Implementations
impl Clone for Level[src]
impl Copy for Level[src]
impl Debug for Level[src]
impl Display for Level[src]
Trait Implementations
impl Clone for Level[src]
impl Copy for Level[src]
impl Debug for Level[src]
impl Display for Level[src]
impl Eq for Level[src]
impl FromStr for Level[src]
type Err = ParseLevelError
The associated error which can be returned from parsing.

-
impl Hash for Level[src]
impl Ord for Level[src]
impl PartialEq<Level> for LevelFilter[src]
impl Ord for Level[src]
impl PartialEq<Level> for LevelFilter[src]
impl PartialEq<Level> for Level[src]
impl PartialEq<Level> for Level[src]
impl PartialEq<LevelFilter> for Level[src]
impl PartialEq<LevelFilter> for Level[src]
impl PartialOrd<Level> for LevelFilter[src]
impl PartialOrd<Level> for LevelFilter[src]
impl PartialOrd<Level> for Level[src]
impl PartialOrd<Level> for Level[src]
impl PartialOrd<LevelFilter> for Level[src]
impl PartialOrd<LevelFilter> for Level[src]
impl StructuralEq for Level[src]
Auto Trait Implementations
impl Send for Level[src]
impl Sync for Level[src]
impl Unpin for Level[src]
Blanket Implementations
impl<T> Any for T where
    T: 'static + ?Sized, [src]
impl<T> Borrow<T> for T where
    T: ?Sized, [src]
impl<T> BorrowMut<T> for T where
    T: ?Sized, [src]
impl<T> From<T> for T[src]
impl<T, U> Into<U> for T where
    U: From<T>, [src]
impl<T, U> TryFrom<U> for T where
    U: Into<T>, [src]
type Error = Infallible
The type returned in the event of a conversion error.

-
impl<T, U> TryInto<U> for T where
    U: TryFrom<T>, [src]
type Error = <U as TryFrom<T>>::Error
The type returned in the event of a conversion error.

-

\ No newline at end of file
+

impl StructuralEq for Level[src]

Auto Trait Implementations

impl Send for Level

impl Sync for Level

impl Unpin for Level

Blanket Implementations

impl<T> Any for T where
    T: 'static + ?Sized, [src]

impl<T> Borrow<T> for T where
    T: ?Sized, [src]

impl<T> BorrowMut<T> for T where
    T: ?Sized, [src]

impl<T> From<T> for T[src]

impl<T, U> Into<U> for T where
    U: From<T>, [src]

impl<T, U> TryFrom<U> for T where
    U: Into<T>, [src]

type Error = Infallible

The type returned in the event of a conversion error.

+

impl<T, U> TryInto<U> for T where
    U: TryFrom<T>, [src]

type Error = <U as TryFrom<T>>::Error

The type returned in the event of a conversion error.

+
+ \ No newline at end of file diff --git a/delog/enum.LevelFilter.html b/delog/enum.LevelFilter.html index df1a367..d7f08c9 100644 --- a/delog/enum.LevelFilter.html +++ b/delog/enum.LevelFilter.html @@ -1,7 +1,7 @@ -delog::LevelFilter - Rust +delog::LevelFilter - Rust -

[−][src]Enum delog::LevelFilter

#[repr(usize)]pub enum LevelFilter {
+
Enum delog::LevelFilter[−][src]
#[repr(usize)]pub enum LevelFilter {
     Off,
     Error,
     Warn,
@@ -19,60 +19,61 @@ to get and set the maximum log level with max_
 
Info
Corresponds to the Info log level.

 
Debug
Corresponds to the Debug log level.

 
Trace
Corresponds to the Trace log level.

-
Implementations
impl LevelFilter[src]
pub fn max() -> LevelFilter[src]
Returns the most verbose logging level filter.

-
pub fn to_level(&self) -> Option<Level>[src]
Converts self to the equivalent Level.

+
Implementations
impl LevelFilter[src]
pub fn max() -> LevelFilter[src]
Returns the most verbose logging level filter.

+
pub fn to_level(&self) -> Option<Level>[src]
Converts self to the equivalent Level.

 
Returns None if self is LevelFilter::Off.

-
pub fn as_str(&self) -> &'static str[src]
Returns the string representation of the LevelFilter.

+
pub fn as_str(&self) -> &'static str[src]
Returns the string representation of the LevelFilter.

 
This returns the same string as the fmt::Display implementation.

-
Trait Implementations
impl Clone for LevelFilter[src]
impl Copy for LevelFilter[src]
impl Debug for LevelFilter[src]
impl Display for LevelFilter[src]
Trait Implementations
impl Clone for LevelFilter[src]
impl Copy for LevelFilter[src]
impl Debug for LevelFilter[src]
impl Display for LevelFilter[src]
impl Eq for LevelFilter[src]
impl FromStr for LevelFilter[src]
type Err = ParseLevelError
The associated error which can be returned from parsing.

-
impl Hash for LevelFilter[src]
impl Ord for LevelFilter[src]
impl PartialEq<Level> for LevelFilter[src]
impl Ord for LevelFilter[src]
impl PartialEq<Level> for LevelFilter[src]
impl PartialEq<LevelFilter> for LevelFilter[src]
impl PartialEq<LevelFilter> for Level[src]
impl PartialEq<LevelFilter> for Level[src]
impl PartialEq<LevelFilter> for LevelFilter[src]
impl PartialOrd<Level> for LevelFilter[src]
impl PartialOrd<Level> for LevelFilter[src]
impl PartialOrd<LevelFilter> for Level[src]
impl PartialOrd<LevelFilter> for Level[src]
impl PartialOrd<LevelFilter> for LevelFilter[src]
impl PartialOrd<LevelFilter> for LevelFilter[src]
impl StructuralEq for LevelFilter[src]
Auto Trait Implementations
Blanket Implementations
impl<T> Any for T where
    T: 'static + ?Sized, [src]
impl<T> Borrow<T> for T where
    T: ?Sized, [src]
impl<T> BorrowMut<T> for T where
    T: ?Sized, [src]
impl<T> From<T> for T[src]
impl<T, U> Into<U> for T where
    U: From<T>, [src]
impl<T, U> TryFrom<U> for T where
    U: Into<T>, [src]
type Error = Infallible
The type returned in the event of a conversion error.

-
impl<T, U> TryInto<U> for T where
    U: TryFrom<T>, [src]
type Error = <U as TryFrom<T>>::Error
The type returned in the event of a conversion error.

-

\ No newline at end of file
+

impl StructuralEq for LevelFilter[src]

Auto Trait Implementations

Blanket Implementations

impl<T> Any for T where
    T: 'static + ?Sized, [src]

impl<T> Borrow<T> for T where
    T: ?Sized, [src]

impl<T> BorrowMut<T> for T where
    T: ?Sized, [src]

impl<T> From<T> for T[src]

impl<T, U> Into<U> for T where
    U: From<T>, [src]

impl<T, U> TryFrom<U> for T where
    U: Into<T>, [src]

type Error = Infallible

The type returned in the event of a conversion error.

+

impl<T, U> TryInto<U> for T where
    U: TryFrom<T>, [src]

type Error = <U as TryFrom<T>>::Error

The type returned in the event of a conversion error.

+
+ \ No newline at end of file diff --git a/delog/fn.dequeue.html b/delog/fn.dequeue.html index 0fb8a50..45871d8 100644 --- a/delog/fn.dequeue.html +++ b/delog/fn.dequeue.html @@ -1,8 +1,9 @@ -delog::dequeue - Rust +delog::dequeue - Rust -

[−][src]Function delog::dequeue

pub unsafe fn dequeue(delogger: impl Delogger, buf: &mut [u8]) -> &str

The core "read from circular buffer" method. Marked unsafe to discourage use!

+

Function delog::dequeue[−][src]

pub unsafe fn dequeue(delogger: impl Delogger, buf: &mut [u8]) -> &str

The core “read from circular buffer” method. Marked unsafe to discourage use!

Safety

Unfortunately exposed for all to see, as the delog! macro needs access to it to implement the logger at call site. Hence marked as unsafe.

-
\ No newline at end of file +
+ \ No newline at end of file diff --git a/delog/fn.enqueue.html b/delog/fn.enqueue.html index 07d56a0..bd6e1c7 100644 --- a/delog/fn.enqueue.html +++ b/delog/fn.enqueue.html @@ -1,8 +1,9 @@ -delog::enqueue - Rust +delog::enqueue - Rust -

[−][src]Function delog::enqueue

pub unsafe fn enqueue(delogger: impl Delogger, record: &Record<'_>)

The core "write to circular buffer" method. Marked unsafe to discourage use!

+

Function delog::enqueue[−][src]

pub unsafe fn enqueue(delogger: impl Delogger, record: &Record<'_>)

The core “write to circular buffer” method. Marked unsafe to discourage use!

Safety

Unfortunately exposed for all to see, as the delog! macro needs access to it to implement the logger at call site. Hence marked as unsafe.

-
\ No newline at end of file +
+ \ No newline at end of file diff --git a/delog/fn.logger.html b/delog/fn.logger.html index ba830fe..b7c8d64 100644 --- a/delog/fn.logger.html +++ b/delog/fn.logger.html @@ -1,5 +1,6 @@ -delog::logger - Rust +delog::logger - Rust -

[−][src]Function delog::logger

pub fn logger() -> &'static mut Option<&'static dyn TryLogWithStatistics>

Returns a reference to the logger (as TryLogWithStatistics implementation)

-
\ No newline at end of file +

Function delog::logger[−][src]

pub fn logger() -> &'static mut Option<&'static dyn TryLogWithStatistics>

Returns a reference to the logger (as TryLogWithStatistics implementation)

+
+ \ No newline at end of file diff --git a/delog/fn.try_enqueue.html b/delog/fn.try_enqueue.html index 6094ca6..f56bbd2 100644 --- a/delog/fn.try_enqueue.html +++ b/delog/fn.try_enqueue.html @@ -1,19 +1,20 @@ -delog::try_enqueue - Rust +delog::try_enqueue - Rust -

[−][src]Function delog::try_enqueue

pub unsafe fn try_enqueue(
    delogger: impl Delogger, 
    record: &Record<'_>
) -> Result<(), ()>

The fallible "write to circular buffer" method. Marked unsafe to discourage use!

+

Function delog::try_enqueue[−][src]

pub unsafe fn try_enqueue(
    delogger: impl Delogger, 
    record: &Record<'_>
) -> Result<(), ()>

The fallible “write to circular buffer” method. Marked unsafe to discourage use!

Safety

Unfortunately exposed for all to see, as the delog! macro needs access to it to implement the logger at call site. Hence marked as unsafe.

This implementation needs some HEAVY testing. It is unsound on PC, where the OS can schedule threads in any manner, but assumed to be sound in ARM Cortex-M NVIC -situations, where interrupts are "nested", in the sense that one may be interrupted, -then the interrupter can, ..., then the interrupter hands back control, ..., and finally +situations, where interrupts are “nested”, in the sense that one may be interrupted, +then the interrupter can, …, then the interrupter hands back control, …, and finally the original caller of this function regains control.

In this situation, we keep track of three counters (read, written, claimed), with invariants read <= written <= claimed. Each writer pessimistically gauges sufficient capacity for its log by checking claimed + size <= read + capacity, accounting for the wraparound. If so, the writer atomically advances the claim counter, and starts copying -its data in this newly claimed space. At the end, it is the duty of the "first" caller +its data in this newly claimed space. At the end, it is the duty of the “first” caller to advance the written counter to the correct state.

-
\ No newline at end of file +
+ \ No newline at end of file diff --git a/delog/hex/fn.HexStr.html b/delog/hex/fn.HexStr.html index b4c8575..ee75c60 100644 --- a/delog/hex/fn.HexStr.html +++ b/delog/hex/fn.HexStr.html @@ -1,7 +1,7 @@ -delog::hex::HexStr - Rust +delog::hex::HexStr - Rust -

[−][src]Function delog::hex::HexStr

pub fn HexStr<T: ?Sized, U: Unsigned, S: Separator>(
    value: &T
) -> HexStr<'_, T, U, S>

Explicitly construct a newtype to format with.

+

Function delog::hex::HexStr[−][src]

pub fn HexStr<T: ?Sized, U: Unsigned, S: Separator>(
    value: &T
) -> HexStr<'_, T, U, S>

Explicitly construct a newtype to format with.

The first generic parameter specifies the block size in bytes, the second parameter the separator string.

This function is just here for documentation of what the hex_str! macro @@ -26,4 +26,5 @@ does internally (using the undocumented typeint! and typesep! let hex_str = HexStr::<_, U3, Pipe>(four_bytes); assert_eq!(format!("{}", hex_str), "07A1FF|C7");

-
\ No newline at end of file +
+ \ No newline at end of file diff --git a/delog/hex/index.html b/delog/hex/index.html index 8a7f3aa..0879139 100644 --- a/delog/hex/index.html +++ b/delog/hex/index.html @@ -1,7 +1,7 @@ -delog::hex - Rust +delog::hex - Rust -

[−][src]Module delog::hex

Convenient Display and other traits for binary data.

+

Module delog::hex[−][src]

Convenient Display and other traits for binary data.

Standard Rust uses the fmt::UpperHex and LowerHex traits to implement hexadecimal representations for use in format strings. For instance, format_args!("{:02X?}", &[7, 0xA1, 0xFF]) produces the string "[07, A1, FF]".

@@ -36,4 +36,5 @@ during formatting.

Unsigned

A type that specifies an unsigned integer.

Functions

HexStr

Explicitly construct a newtype to format with.

-
\ No newline at end of file +
+ \ No newline at end of file diff --git a/delog/hex/struct.HexStr.html b/delog/hex/struct.HexStr.html index 903f0cf..da41f44 100644 --- a/delog/hex/struct.HexStr.html +++ b/delog/hex/struct.HexStr.html @@ -1,7 +1,7 @@ -delog::hex::HexStr - Rust +delog::hex::HexStr - Rust -

[−][src]Struct delog::hex::HexStr

pub struct HexStr<'a, T: ?Sized, U, S> where
    U: Unsigned,
    S: Separator,  {
+
Struct delog::hex::HexStr[−][src]
pub struct HexStr<'a, T: ?Sized, U, S> where
    U: Unsigned,
    S: Separator,  {
     pub value: &'a T,
     // some fields omitted
 }
Zero-sized wrapper newtype, allowing grouping bytes in blocks of N hexadecimals
@@ -14,13 +14,14 @@ or preferrably the hex_str! or hexstr! macro.

impl<T: ?Sized, U, S> Display for HexStr<'_, T, U, S> where
    T: AsRef<[u8]>,
    U: Unsigned,
    S: Separator, [src]

impl<'a, T: ?Sized, U, S> LowerHex for HexStr<'a, T, U, S> where
    T: AsRef<[u8]>,
    U: Unsigned,
    S: Separator, [src]

impl<'a, T: ?Sized, U, S> UpperHex for HexStr<'a, T, U, S> where
    T: AsRef<[u8]>,
    U: Unsigned,
    S: Separator, [src]

Auto Trait Implementations

impl<'a, T: ?Sized, U, S> Send for HexStr<'a, T, U, S> where
    S: Send,
    T: Sync,
    U: Send, [src]

impl<'a, T: ?Sized, U, S> Sync for HexStr<'a, T, U, S> where
    S: Sync,
    T: Sync,
    U: Sync, [src]

impl<'a, T: ?Sized, U, S> Unpin for HexStr<'a, T, U, S> where
    S: Unpin,
    U: Unpin, [src]

Blanket Implementations

impl<T> Any for T where
    T: 'static + ?Sized, [src]

impl<T> Borrow<T> for T where
    T: ?Sized, [src]

impl<T> BorrowMut<T> for T where
    T: ?Sized, [src]

impl<T> From<T> for T[src]

impl<T, U> Into<U> for T where
    U: From<T>, [src]

impl<T, U> TryFrom<U> for T where
    U: Into<T>, [src]

type Error = Infallible

The type returned in the event of a conversion error.

-

impl<T, U> TryInto<U> for T where
    U: TryFrom<T>, [src]

type Error = <U as TryFrom<T>>::Error

The type returned in the event of a conversion error.

-
\ No newline at end of file +

Auto Trait Implementations

impl<'a, T: ?Sized, U, S> Send for HexStr<'a, T, U, S> where
    S: Send,
    T: Sync,
    U: Send, 

impl<'a, T: ?Sized, U, S> Sync for HexStr<'a, T, U, S> where
    S: Sync,
    T: Sync,
    U: Sync, 

impl<'a, T: ?Sized, U, S> Unpin for HexStr<'a, T, U, S> where
    S: Unpin,
    U: Unpin, 

Blanket Implementations

impl<T> Any for T where
    T: 'static + ?Sized, [src]

impl<T> Borrow<T> for T where
    T: ?Sized, [src]

impl<T> BorrowMut<T> for T where
    T: ?Sized, [src]

impl<T> From<T> for T[src]

impl<T, U> Into<U> for T where
    U: From<T>, [src]

impl<T, U> TryFrom<U> for T where
    U: Into<T>, [src]

type Error = Infallible

The type returned in the event of a conversion error.

+

impl<T, U> TryInto<U> for T where
    U: TryFrom<T>, [src]

type Error = <U as TryFrom<T>>::Error

The type returned in the event of a conversion error.

+
+ \ No newline at end of file diff --git a/delog/hex/struct.U1.html b/delog/hex/struct.U1.html index a5242d8..cdb475f 100644 --- a/delog/hex/struct.U1.html +++ b/delog/hex/struct.U1.html @@ -1,15 +1,16 @@ -delog::hex::U1 - Rust +delog::hex::U1 - Rust -

[−][src]Struct delog::hex::U1

pub struct U1;

A type that represents the integer 1.

+

Struct delog::hex::U1[−][src]

pub struct U1;

A type that represents the integer 1.

Trait Implementations

impl Unsigned for U1[src]

Auto Trait Implementations

impl Send for U1[src]

impl Sync for U1[src]

impl Unpin for U1[src]

Blanket Implementations

impl<T> Any for T where
    T: 'static + ?Sized, [src]

impl<T> Borrow<T> for T where
    T: ?Sized, [src]

impl<T> BorrowMut<T> for T where
    T: ?Sized, [src]

impl<T> From<T> for T[src]

impl<T, U> Into<U> for T where
    U: From<T>, [src]

impl<T, U> TryFrom<U> for T where
    U: Into<T>, [src]

type Error = Infallible

The type returned in the event of a conversion error.

-

impl<T, U> TryInto<U> for T where
    U: TryFrom<T>, [src]

type Error = <U as TryFrom<T>>::Error

The type returned in the event of a conversion error.

-
\ No newline at end of file +

Auto Trait Implementations

impl Send for U1

impl Sync for U1

impl Unpin for U1

Blanket Implementations

impl<T> Any for T where
    T: 'static + ?Sized, [src]

impl<T> Borrow<T> for T where
    T: ?Sized, [src]

impl<T> BorrowMut<T> for T where
    T: ?Sized, [src]

impl<T> From<T> for T[src]

impl<T, U> Into<U> for T where
    U: From<T>, [src]

impl<T, U> TryFrom<U> for T where
    U: Into<T>, [src]

type Error = Infallible

The type returned in the event of a conversion error.

+

impl<T, U> TryInto<U> for T where
    U: TryFrom<T>, [src]

type Error = <U as TryFrom<T>>::Error

The type returned in the event of a conversion error.

+
+ \ No newline at end of file diff --git a/delog/hex/trait.Separator.html b/delog/hex/trait.Separator.html index 6cf3cdd..2cb507f 100644 --- a/delog/hex/trait.Separator.html +++ b/delog/hex/trait.Separator.html @@ -1,8 +1,9 @@ -delog::hex::Separator - Rust +delog::hex::Separator - Rust -

[−][src]Trait delog::hex::Separator

pub trait Separator {
+
Trait delog::hex::Separator[−][src]
pub trait Separator {
     const SEPARATOR: &'static str;
 }
A type that specifies a separator str.

 
Associated Constants
const SEPARATOR: &'static str[src]
The actual separator str.

-
Loading content...
Implementors
Loading content...

\ No newline at end of file
+
Loading content...

Implementors

Loading content...
+ \ No newline at end of file diff --git a/delog/hex/trait.Unsigned.html b/delog/hex/trait.Unsigned.html index c4d7adc..afb15a6 100644 --- a/delog/hex/trait.Unsigned.html +++ b/delog/hex/trait.Unsigned.html @@ -1,10 +1,11 @@ -delog::hex::Unsigned - Rust +delog::hex::Unsigned - Rust -

[−][src]Trait delog::hex::Unsigned

pub trait Unsigned {
+
Trait delog::hex::Unsigned[−][src]
pub trait Unsigned {
     const N: usize;
 }
A type that specifies an unsigned integer.

 
We use this instead of typenum as the latter currently lacks
 a mapping from usize to the associated type.

 
Associated Constants
const N: usize[src]
The actual number.

-
Loading content...
Implementors
impl Unsigned for U1[src]
Loading content...

\ No newline at end of file
+
Loading content...

Implementors

impl Unsigned for U1[src]

Loading content...
+ \ No newline at end of file diff --git a/delog/index.html b/delog/index.html index 9a50b84..efb52eb 100644 --- a/delog/index.html +++ b/delog/index.html @@ -1,13 +1,13 @@ -delog - Rust +delog - Rust -

[−][src]Crate delog

Compile-time configurable deferred logging (for printf()-debugging aka tracing)

+

Crate delog[−][src]

Compile-time configurable deferred logging (for printf()-debugging aka tracing)

This is an implementation of the log::Log trait, suitable for use in both embedded and desktop environments.

It has two main goals:

    -
  • logs are stored in a circular static memory buffer, so that logging is "zero-cost in the inner -loop" (apart from the formatting), with deferred actual I/O later via flushing.
    • +
  • logs are stored in a circular static memory buffer, so that logging is “zero-cost in the inner +loop” (apart from the formatting), with deferred actual I/O later via flushing.
  • compile-time log level settings for applications with multiple library components; inactive log levels of libraries are completely compiled out.
@@ -15,13 +15,13 @@ inactive log levels of libraries are completely compiled out. are removed from the final binary.

Usage and defaults

-

"Global settings subtractive (default all), local settings additive (default none) but with kill-switch."

+

“Global settings subtractive (default all), local settings additive (default none) but with kill-switch.”

From log, we inherit:

  • static global filters, default LevelFilter::Trace (i.e., everything), set via delog or log feature flags (multiple settings result in the most restrictive filter)
    • -
  • dynamic global filter, initialized in the "init"/"init_default" constructors of the +
  • dynamic global filter, initialized in the “init”/“init_default” constructors of the macro-generated structs implementing our Delogger trait. This can be changed by calls to the global set_max_level function in log.
@@ -31,7 +31,7 @@ which, by default, do nothing, and are completely optimized out.

If such a libray itself defines a feature log-all that is active, then logging calls with these macros are passed through and goverend by the global filters. Such a library can also define a feature such as log-info, which activates exactly the info-level logs; it is up to the library to define -logic such as "log-info implies log-warn". There is a kill-switch: if the library defines a +logic such as “log-info implies log-warn”. There is a kill-switch: if the library defines a feature log-none, and some intermediate library activates one of the additive log-* features, setting log-none completely turns off logging for this library.

Background

@@ -39,20 +39,20 @@ features, setting log-none completely turns off logging for this li we pursue different values and requirements, namely:

  • compatibility with the standard core::fmt traits and the standard log library API. -This means that, while libraries may "upgrade" their logging capabilities by using delog +This means that, while libraries may “upgrade” their logging capabilities by using delog as drop-in replacement for their logging calls (see below), any existing library that already -uses log is compatible. This, for our use cases, is a huge win, as opposed to using up "weirdness -budget" and requiring custom tooling for something that is often trivial, throw-away, simple logging.
    • +uses log is compatible. This, for our use cases, is a huge win, as opposed to using up “weirdness +budget” and requiring custom tooling for something that is often trivial, throw-away, simple logging.
  • it follows that one can easily drop a trace!("{:?}", &suspicious_object) call at any time for any object that has a (possibly automatically derived) Debug trait implementation – without passing around structures and keeping on top of lifetimes.
    • -
  • deferred logging: This is a typical "shared memory" logger, calls to info! etc. +
  • deferred logging: This is a typical “shared memory” logger, calls to info! etc. are not directly sent to their final output, but instead are stored in a circular buffer -that is "drained" by calling flush on the logger at a convenient moment, for instance +that is “drained” by calling flush on the logger at a convenient moment, for instance in an idle loop.
  • immediate mode logging: Sometimes one wants to bypass the deferred flushing of logs, this is possible using either the little-known target argument to info! and friends -with "!" as parameter, or using the additional immediate_info! and friends macros.
    • +with “!” as parameter, or using the additional immediate_info! and friends macros.
  • ability to set log levels per library, at compile-time. This can be easily retro-fitted on existing log-based libraries, by adding the requisite features in Cargo.toml and replacing log with delog (see gate-tests for examples of this).
    • @@ -63,7 +63,7 @@ which wrap the data in newtypes with custom fmt::UpperHex etc. impl

Non-goals:

    -
  • ultimate speed or code size: Our intention are "normal" logs, not the use of logging/tracing to +
  • ultimate speed or code size: Our intention are “normal” logs, not the use of logging/tracing to for stream binary data to the host. While admittedly the core::fmt-ing facilities are not as efficient as one might hope, in our use cases we have sufficient flash and RAM to use these (and some hope that, someday, eventually, maybe, the formatting machinery will be revisited and @@ -81,12 +81,12 @@ including the example feature. Without them, dependencies are quite

    The current circular buffer implementation (v0.1.0) is definitely unsound on desktop. For embedded use, atomics are required (so no Cortex-M0/M1, and no plans to support non-atomic platforms, which are likely to also be too resource-constrained to support the bloat inherent -in core::fmt). While we think the implemented circular buffer algorithm works for the "nested interrupt" +in core::fmt). While we think the implemented circular buffer algorithm works for the “nested interrupt” setup of NVICs, it has not been tested much. The hope is that the worst case scenario is some slightly messed up log outputs.

    Outlook

    -

    We plan to iterate towards a v0.2.0 soon, making use of a separate "flusher" for the -"immediate" logging path. For instance, when logging via serial-over-USB, one might want immediate +

    We plan to iterate towards a v0.2.0 soon, making use of a separate “flusher” for the +“immediate” logging path. For instance, when logging via serial-over-USB, one might want immediate logs to pend a separate RTIC interrupt handler that blocks until the logs are pushed and read (allowing one to debug the boot process of a firmware), or one might want to just write to RTT (or even semihosting xD) for these, during development.

    @@ -101,7 +101,7 @@ logs to pend a separate RTIC interrupt handler that blocks until the logs are pu hexstr

    More compactly format byte arrays and slices as hexadecimals.

    try_log

    Fallible (ungated) version of log!.

    Structs

    -
    Record

    The "payload" of a log message.

    +
    Record

    The “payload” of a log message.

    Statistics

    Statistics on logger usage.

    Enums

    Level

    An enum representing the available verbosity levels of the logger.

    @@ -114,8 +114,9 @@ logs to pend a separate RTIC interrupt handler that blocks until the logs are pu
    TryLog

    Fallible, panic-free version of the log::Log trait.

    TryLogWithStatistics

    TryLog with some usage statistics on top.

    Functions

    -
    dequeue⚠

    The core "read from circular buffer" method. Marked unsafe to discourage use!

    -
    enqueue⚠

    The core "write to circular buffer" method. Marked unsafe to discourage use!

    +
    dequeue⚠

    The core “read from circular buffer” method. Marked unsafe to discourage use!

    +
    enqueue⚠

    The core “write to circular buffer” method. Marked unsafe to discourage use!

    logger

    Returns a reference to the logger (as TryLogWithStatistics implementation)

    -
    try_enqueue⚠

    The fallible "write to circular buffer" method. Marked unsafe to discourage use!

    -
    \ No newline at end of file +
    try_enqueue⚠

    The fallible “write to circular buffer” method. Marked unsafe to discourage use!

    +
    + \ No newline at end of file diff --git a/delog/macro.delog.html b/delog/macro.delog.html index e131851..6d41e4e 100644 --- a/delog/macro.delog.html +++ b/delog/macro.delog.html @@ -1,14 +1,17 @@ -delog::delog - Rust +delog::delog - Rust -

    [−][src]Macro delog::delog

    +
    Macro delog::delog[−][src]
     macro_rules! delog {
+    ($logger:ident, $capacity:expr, $render_capacity:expr, $flusher:ty) => { ... };
     ($logger:ident, $capacity:expr, $flusher:ty) => { ... };
     ($logger:ident, $capacity:expr, $flusher:ty, renderer: $renderer:ty) => { ... };
+    ($logger:ident, $capacity:expr, $render_capacity:expr, $flusher:ty, renderer: $renderer:ty) => { ... };
 }
    
 
    Generate a deferred logger with specified capacity and flushing mechanism.
    
-
    Note that only the final "runner" generates, initializes and flushes such a deferred logger.
    
+
    Note that only the final “runner” generates, initializes and flushes such a deferred logger.
    
 
    Libraries simply make calls to log::log!, or its drop-in replacement delog::log!,
 and/or its extension delog::log_now!, and/or its alternatives delog::try_log! and  delog::try_log_now,
 and/or the local logging variants local_log!.
    
-
    
\ No newline at end of file
+
    + \ No newline at end of file diff --git a/delog/macro.generate_macros.html b/delog/macro.generate_macros.html index 30bfa97..668bf96 100644 --- a/delog/macro.generate_macros.html +++ b/delog/macro.generate_macros.html @@ -1,7 +1,7 @@ -delog::generate_macros - Rust +delog::generate_macros - Rust -

    [−][src]Macro delog::generate_macros

    +
    Macro delog::generate_macros[−][src]
     macro_rules! generate_macros {
     () => { ... };
 }
    
@@ -10,4 +10,5 @@
 that actally later makes calls to local_warn! etc.
    
 
    To see this in action, compile documentation using cargo doc --features example, or inspect
 the gate-tests/ subdirectory.
    
-
    
\ No newline at end of file
+
    + \ No newline at end of file diff --git a/delog/macro.hex_str.html b/delog/macro.hex_str.html index 6f2f676..bef109b 100644 --- a/delog/macro.hex_str.html +++ b/delog/macro.hex_str.html @@ -1,7 +1,7 @@ -delog::hex_str - Rust +delog::hex_str - Rust -

    [−][src]Macro delog::hex_str

    +
    Macro delog::hex_str[−][src]
     macro_rules! hex_str {
     ($array:expr) => { ... };
     ($array:expr, sep: $separator:expr) => { ... };
@@ -18,4 +18,5 @@
 assert_eq!(format!("{}", hex_str!(four_bytes, 2)), "07A1 FFC7");
 assert_eq!(format!("{}", hex_str!(four_bytes, 2, sep: "|")), "07A1|FFC7");
 assert_eq!(format!("{}", hex_str!(four_bytes, 3)), "07A1FF C7");
    
-
    
\ No newline at end of file
+
    + \ No newline at end of file diff --git a/delog/macro.hexstr.html b/delog/macro.hexstr.html index 77d8585..ad03283 100644 --- a/delog/macro.hexstr.html +++ b/delog/macro.hexstr.html @@ -1,7 +1,7 @@ -delog::hexstr - Rust +delog::hexstr - Rust -

    [−][src]Macro delog::hexstr

    +
    Macro delog::hexstr[−][src]
     macro_rules! hexstr {
     ($array:expr) => { ... };
 }
    
@@ -12,4 +12,5 @@
 let four_bytes = &[7u8, 0xA1, 255, 0xC7];
 assert_eq!(format!("{}", hexstr!(four_bytes)), "07A1FFC7");
 assert_eq!(format!("{:x}", hexstr!(four_bytes)), "07a1ffc7");
    -
    \ No newline at end of file +
    + \ No newline at end of file diff --git a/delog/macro.try_log.html b/delog/macro.try_log.html index 6b911df..1c10379 100644 --- a/delog/macro.try_log.html +++ b/delog/macro.try_log.html @@ -1,11 +1,12 @@ -delog::try_log - Rust +delog::try_log - Rust -

    [−][src]Macro delog::try_log

    +
    Macro delog::try_log[−][src]
     macro_rules! try_log {
     (target: $target:expr, $lvl:expr, $message:expr) => { ... };
     (target: $target:expr, $lvl:expr, $($arg:tt)+) => { ... };
     ($lvl:expr, $($arg:tt)+) => { ... };
 }
    
 
    Fallible (ungated) version of log!.
    
-
    
\ No newline at end of file
+
    + \ No newline at end of file diff --git a/delog/render/fn.default.html b/delog/render/fn.default.html index b58765a..39eeb32 100644 --- a/delog/render/fn.default.html +++ b/delog/render/fn.default.html @@ -1,5 +1,6 @@ -delog::render::default - Rust +delog::render::default - Rust -

    [−][src]Function delog::render::default

    pub fn default() -> &'static DefaultRenderer

    The default, minimal renderer.

    -
    \ No newline at end of file +

    Function delog::render::default[−][src]

    pub fn default() -> &'static DefaultRenderer

    The default, minimal renderer.

    +
    + \ No newline at end of file diff --git a/delog/render/fn.render_arguments.html b/delog/render/fn.render_arguments.html index 88ff5fc..9197f25 100644 --- a/delog/render/fn.render_arguments.html +++ b/delog/render/fn.render_arguments.html @@ -1,7 +1,8 @@ -delog::render::render_arguments - Rust +delog::render::render_arguments - Rust -

    [−][src]Function delog::render::render_arguments

    pub fn render_arguments<'a>(buf: &'a mut [u8], args: Arguments<'_>) -> &'a [u8]

    For some reason, there seems to be no existing method to easily render +

    Function delog::render::render_arguments[−][src]

    pub fn render_arguments<'a>(buf: &'a mut [u8], args: Arguments<'_>) -> &'a [u8]

    For some reason, there seems to be no existing method to easily render fmt::Arguments in a pre-allocated byte array.

    That is what this does.

    -
    \ No newline at end of file +
    + \ No newline at end of file diff --git a/delog/render/fn.render_record.html b/delog/render/fn.render_record.html index 3214381..11c529e 100644 --- a/delog/render/fn.render_record.html +++ b/delog/render/fn.render_record.html @@ -1,5 +1,6 @@ -delog::render::render_record - Rust +delog::render::render_record - Rust -

    [−][src]Function delog::render::render_record

    pub fn render_record<'a>(buf: &'a mut [u8], record: &Record<'_>) -> &'a [u8]

    Render record, based on feature flags.

    -
    \ No newline at end of file +

    Function delog::render::render_record[−][src]

    pub fn render_record<'a>(buf: &'a mut [u8], record: &Record<'_>) -> &'a [u8]

    Render record, based on feature flags.

    +
    + \ No newline at end of file diff --git a/delog/render/index.html b/delog/render/index.html index 633aecf..b111083 100644 --- a/delog/render/index.html +++ b/delog/render/index.html @@ -1,7 +1,7 @@ -delog::render - Rust +delog::render - Rust -

    [−][src]Module delog::render

    The default, minimal renderer, and some helper functions.

    +

    Module delog::render[−][src]

    The default, minimal renderer, and some helper functions.

    Structs

    DefaultRenderer

    Renders just the record.args().

    RipgrepRenderer

    Renders the record.args(), prefixed by level, target, and file, line if they are some.

    @@ -10,4 +10,5 @@
    render_arguments

    For some reason, there seems to be no existing method to easily render fmt::Arguments in a pre-allocated byte array.

    render_record

    Render record, based on feature flags.

    -
    \ No newline at end of file +
+ \ No newline at end of file diff --git a/delog/render/struct.DefaultRenderer.html b/delog/render/struct.DefaultRenderer.html index 9f1f7ec..e0a5e22 100644 --- a/delog/render/struct.DefaultRenderer.html +++ b/delog/render/struct.DefaultRenderer.html @@ -1,18 +1,19 @@ -delog::render::DefaultRenderer - Rust +delog::render::DefaultRenderer - Rust -

[−][src]Struct delog::render::DefaultRenderer

pub struct DefaultRenderer {}

Renders just the record.args().

-

Trait Implementations

impl Clone for DefaultRenderer[src]

impl Copy for DefaultRenderer[src]

impl Renderer for DefaultRenderer[src]

impl Send for DefaultRenderer[src]

impl Sync for DefaultRenderer[src]

Auto Trait Implementations

Blanket Implementations

impl<T> Any for T where
    T: 'static + ?Sized, [src]

impl<T> Borrow<T> for T where
    T: ?Sized, [src]

impl<T> BorrowMut<T> for T where
    T: ?Sized, [src]

impl<T> From<T> for T[src]

impl<T, U> Into<U> for T where
    U: From<T>, [src]

impl<T, U> TryFrom<U> for T where
    U: Into<T>, [src]

type Error = Infallible

The type returned in the event of a conversion error.

+

impl<T, U> TryInto<U> for T where
    U: TryFrom<T>, [src]

type Error = <U as TryFrom<T>>::Error

The type returned in the event of a conversion error.

+
+ \ No newline at end of file diff --git a/delog/render/struct.RipgrepRenderer.html b/delog/render/struct.RipgrepRenderer.html index 811e561..ea0d890 100644 --- a/delog/render/struct.RipgrepRenderer.html +++ b/delog/render/struct.RipgrepRenderer.html @@ -1,18 +1,19 @@ -delog::render::RipgrepRenderer - Rust +delog::render::RipgrepRenderer - Rust -

[−][src]Struct delog::render::RipgrepRenderer

pub struct RipgrepRenderer {}

Renders the record.args(), prefixed by level, target, and file, line if they are some.

-

Trait Implementations

impl Clone for RipgrepRenderer[src]

impl Copy for RipgrepRenderer[src]

impl Renderer for RipgrepRenderer[src]

Auto Trait Implementations

Blanket Implementations

impl<T> Any for T where
    T: 'static + ?Sized, [src]

impl<T> Borrow<T> for T where
    T: ?Sized, [src]

impl<T> BorrowMut<T> for T where
    T: ?Sized, [src]

impl<T> From<T> for T[src]

impl<T, U> Into<U> for T where
    U: From<T>, [src]

impl<T, U> TryFrom<U> for T where
    U: Into<T>, [src]

type Error = Infallible

The type returned in the event of a conversion error.

+

impl<T, U> TryInto<U> for T where
    U: TryFrom<T>, [src]

type Error = <U as TryFrom<T>>::Error

The type returned in the event of a conversion error.

+
+ \ No newline at end of file diff --git a/delog/sidebar-items.js b/delog/sidebar-items.js index b4974f8..0a38f6e 100644 --- a/delog/sidebar-items.js +++ b/delog/sidebar-items.js @@ -1 +1 @@ -initSidebarItems({"enum":[["Level","An enum representing the available verbosity levels of the logger."],["LevelFilter","An enum representing the available verbosity level filters of the logger."]],"fn":[["dequeue","The core \"read from circular buffer\" method. Marked unsafe to discourage use!"],["enqueue","The core \"write to circular buffer\" method. Marked unsafe to discourage use!"],["logger","Returns a reference to the logger (as `TryLogWithStatistics` implementation)"],["try_enqueue","The fallible \"write to circular buffer\" method. Marked unsafe to discourage use!"]],"macro":[["delog","Generate a deferred logger with specified capacity and flushing mechanism."],["generate_macros","Generate logging macros that can be gated by library."],["hex_str","Compactly format byte arrays and slices as hexadecimals."],["hexstr","More compactly format byte arrays and slices as hexadecimals."],["try_log","Fallible (ungated) version of `log!`."]],"mod":[["hex","Convenient `Display` and other traits for binary data."],["render","The default, minimal renderer, and some helper functions."]],"struct":[["Record","The \"payload\" of a log message."],["Statistics","Statistics on logger usage."]],"trait":[["Delogger","Semi-abstract characterization of the deferred loggers that the `delog!` macro produces."],["Flusher","A way to pass on logs, user supplied."],["Renderer","A way to format logs, user supplied."],["State","Trait for either state or statistics of loggers."],["TryLog","Fallible, panic-free version of the `log::Log` trait."],["TryLogWithStatistics","TryLog with some usage statistics on top."]]}); \ No newline at end of file +initSidebarItems({"enum":[["Level","An enum representing the available verbosity levels of the logger."],["LevelFilter","An enum representing the available verbosity level filters of the logger."]],"fn":[["dequeue","The core “read from circular buffer” method. Marked unsafe to discourage use!"],["enqueue","The core “write to circular buffer” method. Marked unsafe to discourage use!"],["logger","Returns a reference to the logger (as `TryLogWithStatistics` implementation)"],["try_enqueue","The fallible “write to circular buffer” method. Marked unsafe to discourage use!"]],"macro":[["delog","Generate a deferred logger with specified capacity and flushing mechanism."],["generate_macros","Generate logging macros that can be gated by library."],["hex_str","Compactly format byte arrays and slices as hexadecimals."],["hexstr","More compactly format byte arrays and slices as hexadecimals."],["try_log","Fallible (ungated) version of `log!`."]],"mod":[["hex","Convenient `Display` and other traits for binary data."],["render","The default, minimal renderer, and some helper functions."]],"struct":[["Record","The “payload” of a log message."],["Statistics","Statistics on logger usage."]],"trait":[["Delogger","Semi-abstract characterization of the deferred loggers that the `delog!` macro produces."],["Flusher","A way to pass on logs, user supplied."],["Renderer","A way to format logs, user supplied."],["State","Trait for either state or statistics of loggers."],["TryLog","Fallible, panic-free version of the `log::Log` trait."],["TryLogWithStatistics","TryLog with some usage statistics on top."]]}); \ No newline at end of file diff --git a/delog/struct.Record.html b/delog/struct.Record.html index 89937ff..da6546b 100644 --- a/delog/struct.Record.html +++ b/delog/struct.Record.html @@ -1,7 +1,7 @@ -delog::Record - Rust +delog::Record - Rust -

[−][src]Struct delog::Record

pub struct Record<'a> { /* fields omitted */ }

The "payload" of a log message.

+

Struct delog::Record[−][src]

pub struct Record<'a> { /* fields omitted */ }

The “payload” of a log message.

Use

Record structures are passed as parameters to the log method of the Log trait. Logger implementors manipulate these @@ -34,26 +34,27 @@ module path, and message of any Record that is passed to it.

} fn flush(&self) {} }
-

Implementations

impl<'a> Record<'a>[src]

pub fn builder() -> RecordBuilder<'a>[src]

Returns a new builder.

-

pub fn args(&self) -> &Arguments<'a>[src]

The message body.

-

pub fn metadata(&self) -> &Metadata<'a>[src]

Metadata about the log directive.

-

pub fn level(&self) -> Level[src]

The verbosity level of the message.

-

pub fn target(&self) -> &'a str[src]

The name of the target of the directive.

-

pub fn module_path(&self) -> Option<&'a str>[src]

The module path of the message.

-

pub fn module_path_static(&self) -> Option<&'static str>[src]

The module path of the message, if it is a 'static string.

-

pub fn file(&self) -> Option<&'a str>[src]

The source file containing the message.

-

pub fn file_static(&self) -> Option<&'static str>[src]

The module path of the message, if it is a 'static string.

-

pub fn line(&self) -> Option<u32>[src]

The line containing the message.

+

Implementations

impl<'a> Record<'a>[src]

pub fn builder() -> RecordBuilder<'a>[src]

Returns a new builder.

+

pub fn args(&self) -> &Arguments<'a>[src]

The message body.

+

pub fn metadata(&self) -> &Metadata<'a>[src]

Metadata about the log directive.

+

pub fn level(&self) -> Level[src]

The verbosity level of the message.

+

pub fn target(&self) -> &'a str[src]

The name of the target of the directive.

+

pub fn module_path(&self) -> Option<&'a str>[src]

The module path of the message.

+

pub fn module_path_static(&self) -> Option<&'static str>[src]

The module path of the message, if it is a 'static string.

+

pub fn file(&self) -> Option<&'a str>[src]

The source file containing the message.

+

pub fn file_static(&self) -> Option<&'static str>[src]

The module path of the message, if it is a 'static string.

+

pub fn line(&self) -> Option<u32>[src]

The line containing the message.

Trait Implementations

impl<'a> Clone for Record<'a>[src]

impl<'a> Debug for Record<'a>[src]

Auto Trait Implementations

impl<'a> !Send for Record<'a>[src]

impl<'a> !Sync for Record<'a>[src]

impl<'a> Unpin for Record<'a>[src]

Blanket Implementations

impl<T> Any for T where
    T: 'static + ?Sized, [src]

impl<T> Borrow<T> for T where
    T: ?Sized, [src]

impl<T> BorrowMut<T> for T where
    T: ?Sized, [src]

impl<T> From<T> for T[src]

impl<T, U> Into<U> for T where
    U: From<T>, [src]

impl<T, U> TryFrom<U> for T where
    U: Into<T>, [src]

type Error = Infallible

The type returned in the event of a conversion error.

-

impl<T, U> TryInto<U> for T where
    U: TryFrom<T>, [src]

type Error = <U as TryFrom<T>>::Error

The type returned in the event of a conversion error.

-
\ No newline at end of file +

Auto Trait Implementations

impl<'a> !Send for Record<'a>

impl<'a> !Sync for Record<'a>

impl<'a> Unpin for Record<'a>

Blanket Implementations

impl<T> Any for T where
    T: 'static + ?Sized, [src]

impl<T> Borrow<T> for T where
    T: ?Sized, [src]

impl<T> BorrowMut<T> for T where
    T: ?Sized, [src]

impl<T> From<T> for T[src]

impl<T, U> Into<U> for T where
    U: From<T>, [src]

impl<T, U> TryFrom<U> for T where
    U: Into<T>, [src]

type Error = Infallible

The type returned in the event of a conversion error.

+

impl<T, U> TryInto<U> for T where
    U: TryFrom<T>, [src]

type Error = <U as TryFrom<T>>::Error

The type returned in the event of a conversion error.

+
+ \ No newline at end of file diff --git a/delog/struct.Statistics.html b/delog/struct.Statistics.html index a068938..40a0c36 100644 --- a/delog/struct.Statistics.html +++ b/delog/struct.Statistics.html @@ -1,7 +1,7 @@ -delog::Statistics - Rust +delog::Statistics - Rust -

[−][src]Struct delog::Statistics

pub struct Statistics {
+
Struct delog::Statistics[−][src]
pub struct Statistics {
     pub attempts: usize,
     pub successes: usize,
     pub flushes: usize,
@@ -15,15 +15,16 @@
 
read: usize
How many bytes were flushed so far.

 
written: usize
How many bytes were logged so far.

 
Trait Implementations
impl Clone for Statistics[src]
impl Copy for Statistics[src]
impl Debug for Statistics[src]
Auto Trait Implementations
Blanket Implementations
impl<T> Any for T where
    T: 'static + ?Sized, [src]
impl<T> Borrow<T> for T where
    T: ?Sized, [src]
impl<T> BorrowMut<T> for T where
    T: ?Sized, [src]
impl<T> From<T> for T[src]
impl<T, U> Into<U> for T where
    U: From<T>, [src]
impl<T, U> TryFrom<U> for T where
    U: Into<T>, [src]
type Error = Infallible
The type returned in the event of a conversion error.

-
impl<T, U> TryInto<U> for T where
    U: TryFrom<T>, [src]
type Error = <U as TryFrom<T>>::Error
The type returned in the event of a conversion error.

-

\ No newline at end of file
+

Auto Trait Implementations

impl Send for Statistics

impl Sync for Statistics

impl Unpin for Statistics

Blanket Implementations

impl<T> Any for T where
    T: 'static + ?Sized, [src]

impl<T> Borrow<T> for T where
    T: ?Sized, [src]

impl<T> BorrowMut<T> for T where
    T: ?Sized, [src]

impl<T> From<T> for T[src]

impl<T, U> Into<U> for T where
    U: From<T>, [src]

impl<T, U> TryFrom<U> for T where
    U: Into<T>, [src]

type Error = Infallible

The type returned in the event of a conversion error.

+

impl<T, U> TryInto<U> for T where
    U: TryFrom<T>, [src]

type Error = <U as TryFrom<T>>::Error

The type returned in the event of a conversion error.

+
+ \ No newline at end of file diff --git a/delog/trait.Delogger.html b/delog/trait.Delogger.html index 569e4c4..1ae1187 100644 --- a/delog/trait.Delogger.html +++ b/delog/trait.Delogger.html @@ -1,7 +1,7 @@ -delog::Delogger - Rust +delog::Delogger - Rust -

[−][src]Trait delog::Delogger

pub unsafe trait Delogger: Log + TryLog + State<&'static AtomicUsize> {
+
Trait delog::Delogger[−][src]
pub unsafe trait Delogger: Log + TryLog + State<&'static AtomicUsize> {
     fn buffer(&self) -> &'static mut [u8];
 
    fn claimed(&self) -> &'static AtomicUsize;
 
    fn flush(&self, logs: &str);
@@ -10,7 +10,7 @@
     fn capacity(&self) -> usize { ... }
 }
Semi-abstract characterization of the deferred loggers that the delog! macro produces.

 
Safety

-
This trait is markes "unsafe" to signal that users should never (need to) "write their own",
+
This trait is markes “unsafe” to signal that users should never (need to) “write their own”,
 but always go through the delog! macro.

 
The user has access to the global logger via delog::logger(), but only as TryLog/Log
 implementation, not with this direct access to implementation details.

@@ -19,4 +19,5 @@ implementation, not with this direct access to implementation details.

 
fn flush(&self, logs: &str)[src]
Call the flusher.

 
fn render(&self, record: &Record<'_>) -> &'static [u8][src]
Actually render the arguments (via internal static buffer).
Loading content...

Provided methods

fn capacity(&self) -> usize[src]

Capacity of circular buffer.

-
Loading content...

Implementors

Loading content...
\ No newline at end of file +Loading content...

Implementors

Loading content...
+ \ No newline at end of file diff --git a/delog/trait.Flusher.html b/delog/trait.Flusher.html index 118a111..4dc5d35 100644 --- a/delog/trait.Flusher.html +++ b/delog/trait.Flusher.html @@ -1,11 +1,12 @@ -delog::Flusher - Rust +delog::Flusher - Rust -

[−][src]Trait delog::Flusher

pub trait Flusher: Debug + Send {
+
Trait delog::Flusher[−][src]
pub trait Flusher: Debug + Send {
     fn flush(&self, logs: &str);
 }
A way to pass on logs, user supplied.

 
In embedded, this is intended to pend an interrupt
 to send the logs off via (USB) serial, semihosting, or similar.

 
On PC, typical implemenation will just println! or eprintln!

 
Required methods
fn flush(&self, logs: &str)[src]
Implementor must handle passed log &str in some hopefully useful way.

-
Loading content...
Implementors
Loading content...

\ No newline at end of file
+
Loading content...

Implementors

Loading content...
+ \ No newline at end of file diff --git a/delog/trait.Renderer.html b/delog/trait.Renderer.html index dc8588c..66d6ded 100644 --- a/delog/trait.Renderer.html +++ b/delog/trait.Renderer.html @@ -1,9 +1,10 @@ -delog::Renderer - Rust +delog::Renderer - Rust -

[−][src]Trait delog::Renderer

pub trait Renderer: Send + Sync {
+
Trait delog::Renderer[−][src]
pub trait Renderer: Send + Sync {
     fn render<'a>(&self, buf: &'a mut [u8], record: &Record<'_>) -> &'a [u8];
 }
A way to format logs, user supplied.

 
Required methods
fn render<'a>(&self, buf: &'a mut [u8], record: &Record<'_>) -> &'a [u8][src]
Implementor must render record into buf, returning the slice containing the rendered
 record.

-
Loading content...
Implementors
impl Renderer for DefaultRenderer[src]
impl Renderer for RipgrepRenderer[src]
Loading content...

\ No newline at end of file
+
Loading content...

Implementors

impl Renderer for DefaultRenderer[src]

impl Renderer for RipgrepRenderer[src]

Loading content...
+ \ No newline at end of file diff --git a/delog/trait.State.html b/delog/trait.State.html index b5d3d58..57b6a8e 100644 --- a/delog/trait.State.html +++ b/delog/trait.State.html @@ -1,7 +1,7 @@ -delog::State - Rust +delog::State - Rust -

[−][src]Trait delog::State

pub trait State<T> {
+
Trait delog::State[−][src]
pub trait State<T> {
     fn attempts(&self) -> T;
 
    fn successes(&self) -> T;
 
    fn flushes(&self) -> T;
@@ -13,4 +13,5 @@
 
fn flushes(&self) -> T[src]
How often was the flusher called.

 
fn read(&self) -> T[src]
How many bytes were flushed so far.

 
fn written(&self) -> T[src]
How many bytes were logged so far.

-
Loading content...

Implementors

Loading content...
\ No newline at end of file +Loading content...

Implementors

Loading content...
+ \ No newline at end of file diff --git a/delog/trait.TryLog.html b/delog/trait.TryLog.html index 45266a3..4906687 100644 --- a/delog/trait.TryLog.html +++ b/delog/trait.TryLog.html @@ -1,13 +1,14 @@ -delog::TryLog - Rust +delog::TryLog - Rust -

[−][src]Trait delog::TryLog

pub trait TryLog: Log {
+
Trait delog::TryLog[−][src]
pub trait TryLog: Log {
     fn try_log(&self, _: &Record<'_>) -> Result<(), ()>;
 }
Fallible, panic-free version of the log::Log trait.

 
The intention is actually that implementors of this trait also
 implement log::Log in a panic-free fashion, and simply drop logs
-that can't be logged. Because, if the user can handle the error, they
+that can’t be logged. Because, if the user can handle the error, they
 would be using the fallible macros, and if not, they most likely do not
 want to crash.

 
Required methods
fn try_log(&self, _: &Record<'_>) -> Result<(), ()>[src]
Fallible logging call (fails when buffer is full)

-
Loading content...
Implementors
Loading content...

\ No newline at end of file
+
Loading content...

Implementors

Loading content...
+ \ No newline at end of file diff --git a/delog/trait.TryLogWithStatistics.html b/delog/trait.TryLogWithStatistics.html index 1f68fc6..ed55f7a 100644 --- a/delog/trait.TryLogWithStatistics.html +++ b/delog/trait.TryLogWithStatistics.html @@ -1,8 +1,9 @@ -delog::TryLogWithStatistics - Rust +delog::TryLogWithStatistics - Rust -

[−][src]Trait delog::TryLogWithStatistics

pub trait TryLogWithStatistics: TryLog + State<usize> {
+
Trait delog::TryLogWithStatistics[−][src]
pub trait TryLogWithStatistics: TryLog + State<usize> {
     fn statistics(&self) -> Statistics { ... }
 }
TryLog with some usage statistics on top.

 
Provided methods
fn statistics(&self) -> Statistics[src]
Read out statistics on logger usage.

-
Loading content...
Implementors
Loading content...

\ No newline at end of file
+
Loading content...

Implementors

Loading content...
+ \ No newline at end of file diff --git a/flexiber/all.html b/flexiber/all.html index 83df7ef..1161c76 100644 --- a/flexiber/all.html +++ b/flexiber/all.html @@ -1,6 +1,7 @@ -List of all items in this crate +List of all items in this crate -

[−] +

List of all items[−] - List of all items

Structs

Enums

Traits

Macros

Derive Macros

Typedefs

\ No newline at end of file +

Structs

Enums

Traits

Macros

Derive Macros

Typedefs

+ \ No newline at end of file diff --git a/flexiber/derive.Decodable.html b/flexiber/derive.Decodable.html index 1384a37..f6370b3 100644 --- a/flexiber/derive.Decodable.html +++ b/flexiber/derive.Decodable.html @@ -1,11 +1,13 @@ -flexiber::Decodable - Rust +flexiber::Decodable - Rust -

[−][src]Derive Macro flexiber::Decodable

#[derive(Decodable)]
+
Derive Macro flexiber::Decodable[−][src]
#[derive(Decodable)]
 {
     // Attributes available to this derive:
     #[tlv]
-}
Derive the Decodable trait on a struct.

+}
+

Derive the Decodable trait on a struct.

See toplevel documentation for the flexiber_derive crate for more information about how to use this macro.

-
\ No newline at end of file +
+ \ No newline at end of file diff --git a/flexiber/derive.Encodable.html b/flexiber/derive.Encodable.html index f1725ae..aa068e3 100644 --- a/flexiber/derive.Encodable.html +++ b/flexiber/derive.Encodable.html @@ -1,11 +1,13 @@ -flexiber::Encodable - Rust +flexiber::Encodable - Rust -

[−][src]Derive Macro flexiber::Encodable

#[derive(Encodable)]
+
Derive Macro flexiber::Encodable[−][src]
#[derive(Encodable)]
 {
     // Attributes available to this derive:
     #[tlv]
-}
Derive the Encodable trait on a struct.

+}
+

Derive the Encodable trait on a struct.

See toplevel documentation for the flexiber_derive crate for more information about how to use this macro.

-
\ No newline at end of file +
+ \ No newline at end of file diff --git a/flexiber/enum.Class.html b/flexiber/enum.Class.html index 0c58f9b..44c75cf 100644 --- a/flexiber/enum.Class.html +++ b/flexiber/enum.Class.html @@ -1,7 +1,7 @@ -flexiber::Class - Rust +flexiber::Class - Rust -

[−][src]Enum flexiber::Class

#[repr(u8)]pub enum Class {
+
Enum flexiber::Class[−][src]
#[repr(u8)]pub enum Class {
     Universal,
     Application,
     Context,
@@ -10,20 +10,21 @@
 

                    Variants

 
Universal
Application
Context
Private
Trait Implementations
impl Clone for Class[src]
impl Copy for Class[src]
impl Debug for Class[src]
impl Eq for Class[src]
impl PartialEq<Class> for Class[src]
impl StructuralEq for Class[src]
impl StructuralPartialEq for Class[src]
impl TryFrom<u8> for Class[src]
type Error = Error
The type returned in the event of a conversion error.

 
Auto Trait Implementations
impl Send for Class[src]
impl Sync for Class[src]
impl Unpin for Class[src]
Blanket Implementations
impl<T> Any for T where
    T: 'static + ?Sized, [src]
impl<T> Borrow<T> for T where
    T: ?Sized, [src]
impl<T> BorrowMut<T> for T where
    T: ?Sized, [src]
impl<T> From<T> for T[src]
impl<T, U> Into<U> for T where
    U: From<T>, [src]
impl<T, U> TryFrom<U> for T where
    U: Into<T>, [src]
type Error = Infallible
The type returned in the event of a conversion error.

-
impl<T, U> TryInto<U> for T where
    U: TryFrom<T>, [src]
type Error = <U as TryFrom<T>>::Error
The type returned in the event of a conversion error.

-

\ No newline at end of file
+

Auto Trait Implementations

impl Send for Class

impl Sync for Class

impl Unpin for Class

Blanket Implementations

impl<T> Any for T where
    T: 'static + ?Sized, [src]

impl<T> Borrow<T> for T where
    T: ?Sized, [src]

impl<T> BorrowMut<T> for T where
    T: ?Sized, [src]

impl<T> From<T> for T[src]

impl<T, U> Into<U> for T where
    U: From<T>, [src]

impl<T, U> TryFrom<U> for T where
    U: Into<T>, [src]

type Error = Infallible

The type returned in the event of a conversion error.

+

impl<T, U> TryInto<U> for T where
    U: TryFrom<T>, [src]

type Error = <U as TryFrom<T>>::Error

The type returned in the event of a conversion error.

+
+ \ No newline at end of file diff --git a/flexiber/enum.ErrorKind.html b/flexiber/enum.ErrorKind.html index 5dbbbcc..3fec09b 100644 --- a/flexiber/enum.ErrorKind.html +++ b/flexiber/enum.ErrorKind.html @@ -1,7 +1,7 @@ -flexiber::ErrorKind - Rust +flexiber::ErrorKind - Rust -

[−][src]Enum flexiber::ErrorKind

#[non_exhaustive]pub enum ErrorKind {
+
Enum flexiber::ErrorKind[−][src]
#[non_exhaustive]pub enum ErrorKind {
     Failed,
     InvalidClass {
         value: u8,
@@ -40,7 +40,7 @@
 
Length
Incorrect length for a given field

 
Fields of Length
tag: Tag
Tag type of the value being decoded

 
Overflow
Integer overflow occurred (library bug!)

-
Overlength
Message is longer than BER-TLV's limits support

+
Overlength
Message is longer than BER-TLV’s limits support

 
TrailingData
Undecoded trailing data at end of message

 
Fields of TrailingData
decoded: Length
Length of the decoded data

 
remaining: Length
Total length of the remaining data left in the buffer

@@ -58,20 +58,21 @@ does not match any of them.

 
Implementations
impl ErrorKind[src]
pub fn at(self, position: Length) -> Error[src]
Annotate an ErrorKind with context about where it occurred,
 returning an error.

 
Trait Implementations
impl Clone for ErrorKind[src]
impl Copy for ErrorKind[src]
impl Debug for ErrorKind[src]
impl Display for ErrorKind[src]
impl Eq for ErrorKind[src]
impl From<ErrorKind> for Error[src]
impl PartialEq<ErrorKind> for ErrorKind[src]
impl StructuralEq for ErrorKind[src]
impl StructuralPartialEq for ErrorKind[src]
Auto Trait Implementations
Blanket Implementations
impl<T> Any for T where
    T: 'static + ?Sized, [src]
impl<T> Borrow<T> for T where
    T: ?Sized, [src]
impl<T> BorrowMut<T> for T where
    T: ?Sized, [src]
impl<T> From<T> for T[src]
impl<T, U> Into<U> for T where
    U: From<T>, [src]
impl<T, U> TryFrom<U> for T where
    U: Into<T>, [src]
type Error = Infallible
The type returned in the event of a conversion error.

-
impl<T, U> TryInto<U> for T where
    U: TryFrom<T>, [src]
type Error = <U as TryFrom<T>>::Error
The type returned in the event of a conversion error.

-

\ No newline at end of file
+

impl StructuralEq for ErrorKind[src]

impl StructuralPartialEq for ErrorKind[src]

Auto Trait Implementations

impl Send for ErrorKind

impl Sync for ErrorKind

impl Unpin for ErrorKind

Blanket Implementations

impl<T> Any for T where
    T: 'static + ?Sized, [src]

impl<T> Borrow<T> for T where
    T: ?Sized, [src]

impl<T> BorrowMut<T> for T where
    T: ?Sized, [src]

impl<T> From<T> for T[src]

impl<T, U> Into<U> for T where
    U: From<T>, [src]

impl<T, U> TryFrom<U> for T where
    U: Into<T>, [src]

type Error = Infallible

The type returned in the event of a conversion error.

+

impl<T, U> TryInto<U> for T where
    U: TryFrom<T>, [src]

type Error = <U as TryFrom<T>>::Error

The type returned in the event of a conversion error.

+
+ \ No newline at end of file diff --git a/flexiber/index.html b/flexiber/index.html index 66b61ab..a15e874 100644 --- a/flexiber/index.html +++ b/flexiber/index.html @@ -1,7 +1,7 @@ -flexiber - Rust +flexiber - Rust -

[−][src]Crate flexiber

flexiber

+

Crate flexiber[−][src]

flexiber

Implementation of the BER-TLV serialization format from ISO 7816-4:2005.

ITU-T X.690 (08/2015) defines the BER, CER and DER encoding rules for ASN.1

The exact same document is ISO/IET 8825-1, which is freely available, @@ -42,7 +42,7 @@ avoided.

Length

BER-TLV-encoded length.

SimpleTag

These are tags like in SIMPLE-TLV.

Slice

Slice of at most Length::max() bytes.

-Tag

The tag field consists of a single byte encoding a tag number from 1 to 254. The values '00' and 'FF' are invalid.

+Tag

The tag field consists of a single byte encoding a tag number from 1 to 254. The values ‘00’ and ‘FF’ are invalid.

TaggedValue

BER-TLV data object.

Enums

Class

Class of BER tag.

@@ -60,4 +60,5 @@ are supposed to implement.

Derive Macros

Decodable

Derive the Decodable trait on a struct.

Encodable

Derive the Encodable trait on a struct.

-
\ No newline at end of file +
+ \ No newline at end of file diff --git a/flexiber/macro.debug.html b/flexiber/macro.debug.html index 4f78e3f..065679a 100644 --- a/flexiber/macro.debug.html +++ b/flexiber/macro.debug.html @@ -1,9 +1,10 @@ -flexiber::debug - Rust +flexiber::debug - Rust -

[−][src]Macro flexiber::debug

+
Macro flexiber::debug[−][src]
 macro_rules! debug {
     ($d($arg:tt)+) => { ... };
 }

 
Local version of debug!.

-

\ No newline at end of file
+
+ \ No newline at end of file diff --git a/flexiber/macro.debug_now.html b/flexiber/macro.debug_now.html index d38cd17..d4968d4 100644 --- a/flexiber/macro.debug_now.html +++ b/flexiber/macro.debug_now.html @@ -1,9 +1,10 @@ -flexiber::debug_now - Rust +flexiber::debug_now - Rust -

[−][src]Macro flexiber::debug_now

+
Macro flexiber::debug_now[−][src]
 macro_rules! debug_now {
     ($d($arg:tt)+) => { ... };
 }

 
Immediate version of debug!.

-

\ No newline at end of file
+
+ \ No newline at end of file diff --git a/flexiber/macro.error.html b/flexiber/macro.error.html index 59ef24a..4b9b89f 100644 --- a/flexiber/macro.error.html +++ b/flexiber/macro.error.html @@ -1,9 +1,10 @@ -flexiber::error - Rust +flexiber::error - Rust -

[−][src]Macro flexiber::error

+
Macro flexiber::error[−][src]
 macro_rules! error {
     ($d($arg:tt)+) => { ... };
 }

 
Local version of error!.

-

\ No newline at end of file
+
+ \ No newline at end of file diff --git a/flexiber/macro.error_now.html b/flexiber/macro.error_now.html index ac2b7f6..4de29e8 100644 --- a/flexiber/macro.error_now.html +++ b/flexiber/macro.error_now.html @@ -1,9 +1,10 @@ -flexiber::error_now - Rust +flexiber::error_now - Rust -

[−][src]Macro flexiber::error_now

+
Macro flexiber::error_now[−][src]
 macro_rules! error_now {
     ($d($arg:tt)+) => { ... };
 }

 
Immediate version of error!.

-

\ No newline at end of file
+
+ \ No newline at end of file diff --git a/flexiber/macro.info.html b/flexiber/macro.info.html index a546caf..b761b6a 100644 --- a/flexiber/macro.info.html +++ b/flexiber/macro.info.html @@ -1,9 +1,10 @@ -flexiber::info - Rust +flexiber::info - Rust -

[−][src]Macro flexiber::info

+
Macro flexiber::info[−][src]
 macro_rules! info {
     ($d($arg:tt)+) => { ... };
 }

 
Local version of info!.

-

\ No newline at end of file
+
+ \ No newline at end of file diff --git a/flexiber/macro.info_now.html b/flexiber/macro.info_now.html index 2802b84..36c1c52 100644 --- a/flexiber/macro.info_now.html +++ b/flexiber/macro.info_now.html @@ -1,9 +1,10 @@ -flexiber::info_now - Rust +flexiber::info_now - Rust -

[−][src]Macro flexiber::info_now

+
Macro flexiber::info_now[−][src]
 macro_rules! info_now {
     ($d($arg:tt)+) => { ... };
 }

 
Immediate version of info!.

-

\ No newline at end of file
+
+ \ No newline at end of file diff --git a/flexiber/macro.log.html b/flexiber/macro.log.html index 4b1a846..3025036 100644 --- a/flexiber/macro.log.html +++ b/flexiber/macro.log.html @@ -1,10 +1,11 @@ -flexiber::log - Rust +flexiber::log - Rust -

[−][src]Macro flexiber::log

+
Macro flexiber::log[−][src]
 macro_rules! log {
     (target: $target:expr, $d($arg:tt)+) => { ... };
     ($d($arg:tt)+) => { ... };
 }

 
Local version of log!.

-

\ No newline at end of file
+
+ \ No newline at end of file diff --git a/flexiber/macro.log_now.html b/flexiber/macro.log_now.html index cf19744..88cbf71 100644 --- a/flexiber/macro.log_now.html +++ b/flexiber/macro.log_now.html @@ -1,9 +1,10 @@ -flexiber::log_now - Rust +flexiber::log_now - Rust -

[−][src]Macro flexiber::log_now

+
Macro flexiber::log_now[−][src]
 macro_rules! log_now {
     ($lvl:expr, $d($arg:tt)+) => { ... };
 }

 
Immediate version of log!.

-

\ No newline at end of file
+
+ \ No newline at end of file diff --git a/flexiber/macro.trace.html b/flexiber/macro.trace.html index 164cd18..d39f482 100644 --- a/flexiber/macro.trace.html +++ b/flexiber/macro.trace.html @@ -1,9 +1,10 @@ -flexiber::trace - Rust +flexiber::trace - Rust -

[−][src]Macro flexiber::trace

+
Macro flexiber::trace[−][src]
 macro_rules! trace {
     ($d($arg:tt)+) => { ... };
 }

 
Local version of trace!.

-

\ No newline at end of file
+
+ \ No newline at end of file diff --git a/flexiber/macro.trace_now.html b/flexiber/macro.trace_now.html index a8817db..df89b37 100644 --- a/flexiber/macro.trace_now.html +++ b/flexiber/macro.trace_now.html @@ -1,9 +1,10 @@ -flexiber::trace_now - Rust +flexiber::trace_now - Rust -

[−][src]Macro flexiber::trace_now

+
Macro flexiber::trace_now[−][src]
 macro_rules! trace_now {
     ($d($arg:tt)+) => { ... };
 }

 
Immediate version of trace!.

-

\ No newline at end of file
+
+ \ No newline at end of file diff --git a/flexiber/macro.try_debug.html b/flexiber/macro.try_debug.html index a4381b9..2f0d01f 100644 --- a/flexiber/macro.try_debug.html +++ b/flexiber/macro.try_debug.html @@ -1,9 +1,10 @@ -flexiber::try_debug - Rust +flexiber::try_debug - Rust -

[−][src]Macro flexiber::try_debug

+
Macro flexiber::try_debug[−][src]
 macro_rules! try_debug {
     ($d($arg:tt)+) => { ... };
 }

 
Fallible version of debug!.

-

\ No newline at end of file
+
+ \ No newline at end of file diff --git a/flexiber/macro.try_debug_now.html b/flexiber/macro.try_debug_now.html index 28ec7b8..efceefc 100644 --- a/flexiber/macro.try_debug_now.html +++ b/flexiber/macro.try_debug_now.html @@ -1,9 +1,10 @@ -flexiber::try_debug_now - Rust +flexiber::try_debug_now - Rust -

[−][src]Macro flexiber::try_debug_now

+
Macro flexiber::try_debug_now[−][src]
 macro_rules! try_debug_now {
     ($d($arg:tt)+) => { ... };
 }

 
Fallible immediate version of debug!.

-

\ No newline at end of file
+
+ \ No newline at end of file diff --git a/flexiber/macro.try_error.html b/flexiber/macro.try_error.html index d386864..033793e 100644 --- a/flexiber/macro.try_error.html +++ b/flexiber/macro.try_error.html @@ -1,9 +1,10 @@ -flexiber::try_error - Rust +flexiber::try_error - Rust -

[−][src]Macro flexiber::try_error

+
Macro flexiber::try_error[−][src]
 macro_rules! try_error {
     ($d($arg:tt)+) => { ... };
 }

 
Fallible version of error!.

-

\ No newline at end of file
+
+ \ No newline at end of file diff --git a/flexiber/macro.try_error_now.html b/flexiber/macro.try_error_now.html index 0846c6f..9ef0169 100644 --- a/flexiber/macro.try_error_now.html +++ b/flexiber/macro.try_error_now.html @@ -1,9 +1,10 @@ -flexiber::try_error_now - Rust +flexiber::try_error_now - Rust -

[−][src]Macro flexiber::try_error_now

+
Macro flexiber::try_error_now[−][src]
 macro_rules! try_error_now {
     ($d($arg:tt)+) => { ... };
 }

 
Fallible immediate version of error!.

-

\ No newline at end of file
+
+ \ No newline at end of file diff --git a/flexiber/macro.try_info.html b/flexiber/macro.try_info.html index 50f5348..2b7625e 100644 --- a/flexiber/macro.try_info.html +++ b/flexiber/macro.try_info.html @@ -1,9 +1,10 @@ -flexiber::try_info - Rust +flexiber::try_info - Rust -

[−][src]Macro flexiber::try_info

+
Macro flexiber::try_info[−][src]
 macro_rules! try_info {
     ($d($arg:tt)+) => { ... };
 }

 
Fallible version of info!.

-

\ No newline at end of file
+
+ \ No newline at end of file diff --git a/flexiber/macro.try_info_now.html b/flexiber/macro.try_info_now.html index b559d84..d1918f5 100644 --- a/flexiber/macro.try_info_now.html +++ b/flexiber/macro.try_info_now.html @@ -1,9 +1,10 @@ -flexiber::try_info_now - Rust +flexiber::try_info_now - Rust -

[−][src]Macro flexiber::try_info_now

+
Macro flexiber::try_info_now[−][src]
 macro_rules! try_info_now {
     ($d($arg:tt)+) => { ... };
 }

 
Fallible immediate version of info!.

-

\ No newline at end of file
+
+ \ No newline at end of file diff --git a/flexiber/macro.try_log_now.html b/flexiber/macro.try_log_now.html index 6fcc652..71f5eee 100644 --- a/flexiber/macro.try_log_now.html +++ b/flexiber/macro.try_log_now.html @@ -1,9 +1,10 @@ -flexiber::try_log_now - Rust +flexiber::try_log_now - Rust -

[−][src]Macro flexiber::try_log_now

+
Macro flexiber::try_log_now[−][src]
 macro_rules! try_log_now {
     ($lvl:expr, $d($arg:tt)+) => { ... };
 }

 
Fallible immediate version of log!.

-

\ No newline at end of file
+
+ \ No newline at end of file diff --git a/flexiber/macro.try_trace.html b/flexiber/macro.try_trace.html index 6259ce0..83111ba 100644 --- a/flexiber/macro.try_trace.html +++ b/flexiber/macro.try_trace.html @@ -1,10 +1,11 @@ -flexiber::try_trace - Rust +flexiber::try_trace - Rust -

[−][src]Macro flexiber::try_trace

+
Macro flexiber::try_trace[−][src]
 macro_rules! try_trace {
     (target: $target:expr, $d($arg:tt)+) => { ... };
     ($d($arg:tt)+) => { ... };
 }

 
Fallible version of trace!.

-

\ No newline at end of file
+
+ \ No newline at end of file diff --git a/flexiber/macro.try_trace_now.html b/flexiber/macro.try_trace_now.html index 01a08ac..2a4b53a 100644 --- a/flexiber/macro.try_trace_now.html +++ b/flexiber/macro.try_trace_now.html @@ -1,9 +1,10 @@ -flexiber::try_trace_now - Rust +flexiber::try_trace_now - Rust -

[−][src]Macro flexiber::try_trace_now

+
Macro flexiber::try_trace_now[−][src]
 macro_rules! try_trace_now {
     ($d($arg:tt)+) => { ... };
 }

 
Fallible immediate version of trace!.

-

\ No newline at end of file
+
+ \ No newline at end of file diff --git a/flexiber/macro.try_warn.html b/flexiber/macro.try_warn.html index 134889a..53ac441 100644 --- a/flexiber/macro.try_warn.html +++ b/flexiber/macro.try_warn.html @@ -1,10 +1,11 @@ -flexiber::try_warn - Rust +flexiber::try_warn - Rust -

[−][src]Macro flexiber::try_warn

+
Macro flexiber::try_warn[−][src]
 macro_rules! try_warn {
     (target: $target:expr, $d($arg:tt)+) => { ... };
     ($d($arg:tt)+) => { ... };
 }

 
Fallible version of warn!.

-

\ No newline at end of file
+
+ \ No newline at end of file diff --git a/flexiber/macro.try_warn_now.html b/flexiber/macro.try_warn_now.html index 4b87fb2..58d8ce5 100644 --- a/flexiber/macro.try_warn_now.html +++ b/flexiber/macro.try_warn_now.html @@ -1,9 +1,10 @@ -flexiber::try_warn_now - Rust +flexiber::try_warn_now - Rust -

[−][src]Macro flexiber::try_warn_now

+
Macro flexiber::try_warn_now[−][src]
 macro_rules! try_warn_now {
     ($d($arg:tt)+) => { ... };
 }

 
Fallible immediate version of warn!.

-

\ No newline at end of file
+
+ \ No newline at end of file diff --git a/flexiber/macro.warn.html b/flexiber/macro.warn.html index 8bf1b9b..517b286 100644 --- a/flexiber/macro.warn.html +++ b/flexiber/macro.warn.html @@ -1,9 +1,10 @@ -flexiber::warn - Rust +flexiber::warn - Rust -

[−][src]Macro flexiber::warn

+
Macro flexiber::warn[−][src]
 macro_rules! warn {
     ($d($arg:tt)+) => { ... };
 }

 
Local version of warn!.

-

\ No newline at end of file
+
+ \ No newline at end of file diff --git a/flexiber/macro.warn_now.html b/flexiber/macro.warn_now.html index fa6affd..b0baab0 100644 --- a/flexiber/macro.warn_now.html +++ b/flexiber/macro.warn_now.html @@ -1,9 +1,10 @@ -flexiber::warn_now - Rust +flexiber::warn_now - Rust -

[−][src]Macro flexiber::warn_now

+
Macro flexiber::warn_now[−][src]
 macro_rules! warn_now {
     ($d($arg:tt)+) => { ... };
 }

 
Immediate version of warn!.

-

\ No newline at end of file
+
+ \ No newline at end of file diff --git a/flexiber/sidebar-items.js b/flexiber/sidebar-items.js index e001057..80541f7 100644 --- a/flexiber/sidebar-items.js +++ b/flexiber/sidebar-items.js @@ -1 +1 @@ -initSidebarItems({"derive":[["Decodable","Derive the `Decodable` trait on a struct."],["Encodable","Derive the `Encodable` trait on a struct."]],"enum":[["Class","Class of BER tag."],["ErrorKind","Error type."]],"macro":[["debug","Local version of `debug!`."],["debug_now","Immediate version of `debug!`."],["error","Local version of `error!`."],["error_now","Immediate version of `error!`."],["info","Local version of `info!`."],["info_now","Immediate version of `info!`."],["log","Local version of `log!`."],["log_now","Immediate version of `log!`."],["trace","Local version of `trace!`."],["trace_now","Immediate version of `trace!`."],["try_debug","Fallible version of `debug!`."],["try_debug_now","Fallible immediate version of `debug!`."],["try_error","Fallible version of `error!`."],["try_error_now","Fallible immediate version of `error!`."],["try_info","Fallible version of `info!`."],["try_info_now","Fallible immediate version of `info!`."],["try_log_now","Fallible immediate version of `log!`."],["try_trace","Fallible version of `trace!`."],["try_trace_now","Fallible immediate version of `trace!`."],["try_warn","Fallible version of `warn!`."],["try_warn_now","Fallible immediate version of `warn!`."],["warn","Local version of `warn!`."],["warn_now","Immediate version of `warn!`."]],"struct":[["Decoder","BER-TLV decoder."],["Encoder","BER-TLV encoder."],["Error","Error type."],["Length","BER-TLV-encoded length."],["SimpleTag","These are tags like in SIMPLE-TLV."],["Slice","Slice of at most `Length::max()` bytes."],["Tag","The tag field consists of a single byte encoding a tag number from 1 to 254. The values '00' and 'FF' are invalid."],["TaggedValue","BER-TLV data object."]],"trait":[["Container","Multiple encodables in a container."],["Decodable","Decoding trait."],["Encodable","Encoding trait."],["TagLike","This is the common trait that types to be used as tags are supposed to implement."],["Tagged","Types with an associated BER-TLV [`Tag`]."]],"type":[["Result","Result type."],["TaggedSlice","Raw BER-TLV data object `TaggedValue>`."]]}); \ No newline at end of file +initSidebarItems({"derive":[["Decodable","Derive the `Decodable` trait on a struct."],["Encodable","Derive the `Encodable` trait on a struct."]],"enum":[["Class","Class of BER tag."],["ErrorKind","Error type."]],"macro":[["debug","Local version of `debug!`."],["debug_now","Immediate version of `debug!`."],["error","Local version of `error!`."],["error_now","Immediate version of `error!`."],["info","Local version of `info!`."],["info_now","Immediate version of `info!`."],["log","Local version of `log!`."],["log_now","Immediate version of `log!`."],["trace","Local version of `trace!`."],["trace_now","Immediate version of `trace!`."],["try_debug","Fallible version of `debug!`."],["try_debug_now","Fallible immediate version of `debug!`."],["try_error","Fallible version of `error!`."],["try_error_now","Fallible immediate version of `error!`."],["try_info","Fallible version of `info!`."],["try_info_now","Fallible immediate version of `info!`."],["try_log_now","Fallible immediate version of `log!`."],["try_trace","Fallible version of `trace!`."],["try_trace_now","Fallible immediate version of `trace!`."],["try_warn","Fallible version of `warn!`."],["try_warn_now","Fallible immediate version of `warn!`."],["warn","Local version of `warn!`."],["warn_now","Immediate version of `warn!`."]],"struct":[["Decoder","BER-TLV decoder."],["Encoder","BER-TLV encoder."],["Error","Error type."],["Length","BER-TLV-encoded length."],["SimpleTag","These are tags like in SIMPLE-TLV."],["Slice","Slice of at most `Length::max()` bytes."],["Tag","The tag field consists of a single byte encoding a tag number from 1 to 254. The values ‘00’ and ‘FF’ are invalid."],["TaggedValue","BER-TLV data object."]],"trait":[["Container","Multiple encodables in a container."],["Decodable","Decoding trait."],["Encodable","Encoding trait."],["TagLike","This is the common trait that types to be used as tags are supposed to implement."],["Tagged","Types with an associated BER-TLV [`Tag`]."]],"type":[["Result","Result type."],["TaggedSlice","Raw BER-TLV data object `TaggedValue>`."]]}); \ No newline at end of file diff --git a/flexiber/struct.Decoder.html b/flexiber/struct.Decoder.html index ce33360..41d5c17 100644 --- a/flexiber/struct.Decoder.html +++ b/flexiber/struct.Decoder.html @@ -1,7 +1,7 @@ -flexiber::Decoder - Rust +flexiber::Decoder - Rust -

[−][src]Struct flexiber::Decoder

pub struct Decoder<'a> { /* fields omitted */ }

BER-TLV decoder.

+

Struct flexiber::Decoder[−][src]

pub struct Decoder<'a> { /* fields omitted */ }

BER-TLV decoder.

Implementations

impl<'a> Decoder<'a>[src]

pub fn new(bytes: &'a [u8]) -> Self[src]

Create a new decoder for the given byte slice.

pub fn decode<T: Decodable<'a>>(&mut self) -> Result<T>[src]

Decode a value which impls the Decodable trait.

pub fn decode_tagged_value<T: Decodable<'a> + TagLike, V: Decodable<'a>>(
    &mut self,
    tag: T
) -> Result<V>[src]

Decode a TaggedValue with tag checked to be as expected, returning the value

@@ -12,17 +12,18 @@ context about where the error occurred.

pub fn finish<T>(self, value: T) -> Result<T>[src]

Finish decoding, returning the given value if there is no remaining data, or an error otherwise

pub fn is_finished(&self) -> bool[src]

Have we decoded all of the bytes in this Decoder?

-

Returns false if we're not finished decoding or if a fatal error +

Returns false if we’re not finished decoding or if a fatal error has occurred.

Trait Implementations

impl<'a> Debug for Decoder<'a>[src]

impl<'a> From<&'a [u8]> for Decoder<'a>[src]

Auto Trait Implementations

impl<'a> Send for Decoder<'a>[src]

impl<'a> Sync for Decoder<'a>[src]

impl<'a> Unpin for Decoder<'a>[src]

Blanket Implementations

impl<T> Any for T where
    T: 'static + ?Sized, [src]

impl<T> Borrow<T> for T where
    T: ?Sized, [src]

impl<T> BorrowMut<T> for T where
    T: ?Sized, [src]

impl<T> From<T> for T[src]

impl<T, U> Into<U> for T where
    U: From<T>, [src]

impl<T, U> TryFrom<U> for T where
    U: Into<T>, [src]

type Error = Infallible

The type returned in the event of a conversion error.

-

impl<T, U> TryInto<U> for T where
    U: TryFrom<T>, [src]

type Error = <U as TryFrom<T>>::Error

The type returned in the event of a conversion error.

-
\ No newline at end of file +

Auto Trait Implementations

impl<'a> Send for Decoder<'a>

impl<'a> Sync for Decoder<'a>

impl<'a> Unpin for Decoder<'a>

Blanket Implementations

impl<T> Any for T where
    T: 'static + ?Sized, [src]

impl<T> Borrow<T> for T where
    T: ?Sized, [src]

impl<T> BorrowMut<T> for T where
    T: ?Sized, [src]

impl<T> From<T> for T[src]

impl<T, U> Into<U> for T where
    U: From<T>, [src]

impl<T, U> TryFrom<U> for T where
    U: Into<T>, [src]

type Error = Infallible

The type returned in the event of a conversion error.

+

impl<T, U> TryInto<U> for T where
    U: TryFrom<T>, [src]

type Error = <U as TryFrom<T>>::Error

The type returned in the event of a conversion error.

+
+ \ No newline at end of file diff --git a/flexiber/struct.Encoder.html b/flexiber/struct.Encoder.html index 7546b1b..8df182d 100644 --- a/flexiber/struct.Encoder.html +++ b/flexiber/struct.Encoder.html @@ -1,7 +1,7 @@ -flexiber::Encoder - Rust +flexiber::Encoder - Rust -

[−][src]Struct flexiber::Encoder

pub struct Encoder<'a> { /* fields omitted */ }

BER-TLV encoder.

+

Struct flexiber::Encoder[−][src]

pub struct Encoder<'a> { /* fields omitted */ }

BER-TLV encoder.

Implementations

impl<'a> Encoder<'a>[src]

pub fn new(bytes: &'a mut [u8]) -> Self[src]

Create a new encoder with the given byte slice as a backing buffer.

pub fn encode<T: Encodable>(&mut self, encodable: &T) -> Result<()>[src]

Encode a value which impls the Encodable trait.

pub fn error<T>(&mut self, kind: ErrorKind) -> Result<T>[src]

Return an error with the given ErrorKind, annotating it with @@ -12,13 +12,14 @@ written to the buffer.

pub fn encode_tagged_collection(
    &mut self,
    tag: Tag,
    encodables: &[&dyn Encodable]
) -> Result<()>[src]

Encode a collection of values which impl the Encodable trait under a given tag.

pub fn encode_untagged_collection(
    &mut self,
    encodables: &[&dyn Encodable]
) -> Result<()>[src]

Encode a collection of values which impl the Encodable trait under a given tag.

Trait Implementations

impl<'a> Debug for Encoder<'a>[src]

Auto Trait Implementations

impl<'a> Send for Encoder<'a>[src]

impl<'a> Sync for Encoder<'a>[src]

impl<'a> Unpin for Encoder<'a>[src]

Blanket Implementations

impl<T> Any for T where
    T: 'static + ?Sized, [src]

impl<T> Borrow<T> for T where
    T: ?Sized, [src]

impl<T> BorrowMut<T> for T where
    T: ?Sized, [src]

impl<T> From<T> for T[src]

impl<T, U> Into<U> for T where
    U: From<T>, [src]

impl<T, U> TryFrom<U> for T where
    U: Into<T>, [src]

type Error = Infallible

The type returned in the event of a conversion error.

-

impl<T, U> TryInto<U> for T where
    U: TryFrom<T>, [src]

type Error = <U as TryFrom<T>>::Error

The type returned in the event of a conversion error.

-
\ No newline at end of file +

Auto Trait Implementations

impl<'a> Send for Encoder<'a>

impl<'a> Sync for Encoder<'a>

impl<'a> Unpin for Encoder<'a>

Blanket Implementations

impl<T> Any for T where
    T: 'static + ?Sized, [src]

impl<T> Borrow<T> for T where
    T: ?Sized, [src]

impl<T> BorrowMut<T> for T where
    T: ?Sized, [src]

impl<T> From<T> for T[src]

impl<T, U> Into<U> for T where
    U: From<T>, [src]

impl<T, U> TryFrom<U> for T where
    U: Into<T>, [src]

type Error = Infallible

The type returned in the event of a conversion error.

+

impl<T, U> TryInto<U> for T where
    U: TryFrom<T>, [src]

type Error = <U as TryFrom<T>>::Error

The type returned in the event of a conversion error.

+
+ \ No newline at end of file diff --git a/flexiber/struct.Error.html b/flexiber/struct.Error.html index 8debaa0..db5474c 100644 --- a/flexiber/struct.Error.html +++ b/flexiber/struct.Error.html @@ -1,14 +1,14 @@ -flexiber::Error - Rust +flexiber::Error - Rust -

[−][src]Struct flexiber::Error

pub struct Error { /* fields omitted */ }

Error type.

+

Struct flexiber::Error[−][src]

pub struct Error { /* fields omitted */ }

Error type.

Implementations

impl Error[src]

pub fn new(kind: ErrorKind, position: Length) -> Error[src]

Create a new Error

pub fn kind(self) -> ErrorKind[src]

Get the ErrorKind which occurred.

pub fn position(self) -> Option<Length>[src]

Get the position inside of the message where the error occurred.

pub fn nested(self, nested_position: Length) -> Self[src]

For errors occurring inside of a nested message, extend the position count by the location where the nested message occurs.

Trait Implementations

impl Clone for Error[src]

impl Copy for Error[src]

impl Debug for Error[src]

impl Display for Error[src]

impl Eq for Error[src]

impl From<ErrorKind> for Error[src]

impl PartialEq<Error> for Error[src]

impl StructuralEq for Error[src]

impl StructuralPartialEq for Error[src]

Auto Trait Implementations

impl Send for Error[src]

impl Sync for Error[src]

impl Unpin for Error[src]

Blanket Implementations

impl<T> Any for T where
    T: 'static + ?Sized, [src]

impl<T> Borrow<T> for T where
    T: ?Sized, [src]

impl<T> BorrowMut<T> for T where
    T: ?Sized, [src]

impl<T> From<T> for T[src]

impl<T, U> Into<U> for T where
    U: From<T>, [src]

impl<T, U> TryFrom<U> for T where
    U: Into<T>, [src]

type Error = Infallible

The type returned in the event of a conversion error.

-

impl<T, U> TryInto<U> for T where
    U: TryFrom<T>, [src]

type Error = <U as TryFrom<T>>::Error

The type returned in the event of a conversion error.

-
\ No newline at end of file +

impl StructuralEq for Error[src]

impl StructuralPartialEq for Error[src]

Auto Trait Implementations

impl Send for Error

impl Sync for Error

impl Unpin for Error

Blanket Implementations

impl<T> Any for T where
    T: 'static + ?Sized, [src]

impl<T> Borrow<T> for T where
    T: ?Sized, [src]

impl<T> BorrowMut<T> for T where
    T: ?Sized, [src]

impl<T> From<T> for T[src]

impl<T, U> Into<U> for T where
    U: From<T>, [src]

impl<T, U> TryFrom<U> for T where
    U: Into<T>, [src]

type Error = Infallible

The type returned in the event of a conversion error.

+

impl<T, U> TryInto<U> for T where
    U: TryFrom<T>, [src]

type Error = <U as TryFrom<T>>::Error

The type returned in the event of a conversion error.

+
+ \ No newline at end of file diff --git a/flexiber/struct.Length.html b/flexiber/struct.Length.html index 784e9ba..3c590ab 100644 --- a/flexiber/struct.Length.html +++ b/flexiber/struct.Length.html @@ -1,7 +1,7 @@ -flexiber::Length - Rust +flexiber::Length - Rust -

[−][src]Struct flexiber::Length

pub struct Length(_);

BER-TLV-encoded length.

+

Struct flexiber::Length[−][src]

pub struct Length(_);

BER-TLV-encoded length.

By definition, in the range 0..=65535

The length field consists of one or three consecutive bytes.

    @@ -24,11 +24,11 @@ big-endian integer, with any value from zero to 65,535.

impl Add<usize> for Length[src]

type Output = Result<Self>

The resulting type after applying the + operator.

impl Clone for Length[src]

impl Copy for Length[src]

impl Debug for Length[src]

impl Decodable<'_> for Length[src]

impl Default for Length[src]

impl Default for Length[src]

impl Display for Length[src]

impl Encodable for Length[src]

Auto Trait Implementations

Blanket Implementations

impl<T> Any for T where
    T: 'static + ?Sized, [src]

impl<T> Borrow<T> for T where
    T: ?Sized, [src]

impl<T> BorrowMut<T> for T where
    T: ?Sized, [src]

impl<T> From<T> for T[src]

impl<T, U> Into<U> for T where
    U: From<T>, [src]

impl<T, U> TryFrom<U> for T where
    U: Into<T>, [src]

type Error = Infallible

The type returned in the event of a conversion error.

-

impl<T, U> TryInto<U> for T where
    U: TryFrom<T>, [src]

type Error = <U as TryFrom<T>>::Error

The type returned in the event of a conversion error.

-
\ No newline at end of file +

Auto Trait Implementations

impl Send for Length

impl Sync for Length

impl Unpin for Length

Blanket Implementations

impl<T> Any for T where
    T: 'static + ?Sized, [src]

impl<T> Borrow<T> for T where
    T: ?Sized, [src]

impl<T> BorrowMut<T> for T where
    T: ?Sized, [src]

impl<T> From<T> for T[src]

impl<T, U> Into<U> for T where
    U: From<T>, [src]

impl<T, U> TryFrom<U> for T where
    U: Into<T>, [src]

type Error = Infallible

The type returned in the event of a conversion error.

+

impl<T, U> TryInto<U> for T where
    U: TryFrom<T>, [src]

type Error = <U as TryFrom<T>>::Error

The type returned in the event of a conversion error.

+
+ \ No newline at end of file diff --git a/flexiber/struct.SimpleTag.html b/flexiber/struct.SimpleTag.html index d0f7713..73dfb71 100644 --- a/flexiber/struct.SimpleTag.html +++ b/flexiber/struct.SimpleTag.html @@ -1,13 +1,13 @@ -flexiber::SimpleTag - Rust +flexiber::SimpleTag - Rust -

[−][src]Struct flexiber::SimpleTag

pub struct SimpleTag(_);

These are tags like in SIMPLE-TLV.

-

The tag field consists of a single byte encoding a tag number from 1 to 254. The values '00' and 'FF' are invalid.

+

Struct flexiber::SimpleTag[−][src]

pub struct SimpleTag(_);

These are tags like in SIMPLE-TLV.

+

The tag field consists of a single byte encoding a tag number from 1 to 254. The values ‘00’ and ‘FF’ are invalid.

The use case is that PIV (FIPS 201) data objects generally use BER-TLV, but, for historical reasons, -label entries with "simple" tags (in particular, tag numbers larger than 30 are still encoded +label entries with “simple” tags (in particular, tag numbers larger than 30 are still encoded as single bytes.

Trait Implementations

impl Clone for SimpleTag[src]

impl Copy for SimpleTag[src]

impl Decodable<'_> for SimpleTag[src]

impl Encodable for SimpleTag[src]

impl TryFrom<u8> for SimpleTag[src]

type Error = Error

The type returned in the event of a conversion error.

Auto Trait Implementations

Blanket Implementations

impl<T> Any for T where
    T: 'static + ?Sized, [src]

impl<T> Borrow<T> for T where
    T: ?Sized, [src]

impl<T> BorrowMut<T> for T where
    T: ?Sized, [src]

impl<T> From<T> for T[src]

impl<T, U> Into<U> for T where
    U: From<T>, [src]

impl<T, U> TryFrom<U> for T where
    U: Into<T>, [src]

type Error = Infallible

The type returned in the event of a conversion error.

-

impl<T, U> TryInto<U> for T where
    U: TryFrom<T>, [src]

type Error = <U as TryFrom<T>>::Error

The type returned in the event of a conversion error.

-
\ No newline at end of file +

Auto Trait Implementations

impl Send for SimpleTag

impl Sync for SimpleTag

impl Unpin for SimpleTag

Blanket Implementations

impl<T> Any for T where
    T: 'static + ?Sized, [src]

impl<T> Borrow<T> for T where
    T: ?Sized, [src]

impl<T> BorrowMut<T> for T where
    T: ?Sized, [src]

impl<T> From<T> for T[src]

impl<T, U> Into<U> for T where
    U: From<T>, [src]

impl<T, U> TryFrom<U> for T where
    U: Into<T>, [src]

type Error = Infallible

The type returned in the event of a conversion error.

+

impl<T, U> TryInto<U> for T where
    U: TryFrom<T>, [src]

type Error = <U as TryFrom<T>>::Error

The type returned in the event of a conversion error.

+
+ \ No newline at end of file diff --git a/flexiber/struct.Slice.html b/flexiber/struct.Slice.html index 1b7c69b..91c3c9f 100644 --- a/flexiber/struct.Slice.html +++ b/flexiber/struct.Slice.html @@ -1,7 +1,7 @@ -flexiber::Slice - Rust +flexiber::Slice - Rust -

[−][src]Struct flexiber::Slice

pub struct Slice<'a> { /* fields omitted */ }

Slice of at most Length::max() bytes.

+

Struct flexiber::Slice[−][src]

pub struct Slice<'a> { /* fields omitted */ }

Slice of at most Length::max() bytes.

Implementations

impl<'a> Slice<'a>[src]

pub fn new(slice: &'a [u8]) -> Result<Self>[src]

Create a new Slice, ensuring that the provided slice value is shorter than Length::max().

pub fn as_bytes(&self) -> &'a [u8][src]

Borrow the inner byte slice

@@ -9,18 +9,19 @@ is shorter than Length::max().

pub fn is_empty(self) -> bool[src]

Is this Slice empty?

Trait Implementations

impl AsRef<[u8]> for Slice<'_>[src]

impl<'a> Clone for Slice<'a>[src]

impl<'a> Copy for Slice<'a>[src]

impl<'a> Debug for Slice<'a>[src]

impl<'a> Eq for Slice<'a>[src]

impl<'a> PartialEq<Slice<'a>> for Slice<'a>[src]

impl<'a> StructuralEq for Slice<'a>[src]

impl<'a> StructuralPartialEq for Slice<'a>[src]

Auto Trait Implementations

impl<'a> Send for Slice<'a>[src]

impl<'a> Sync for Slice<'a>[src]

impl<'a> Unpin for Slice<'a>[src]

Blanket Implementations

impl<T> Any for T where
    T: 'static + ?Sized, [src]

impl<T> Borrow<T> for T where
    T: ?Sized, [src]

impl<T> BorrowMut<T> for T where
    T: ?Sized, [src]

impl<T> From<T> for T[src]

impl<T, U> Into<U> for T where
    U: From<T>, [src]

impl<T, U> TryFrom<U> for T where
    U: Into<T>, [src]

type Error = Infallible

The type returned in the event of a conversion error.

-

impl<T, U> TryInto<U> for T where
    U: TryFrom<T>, [src]

type Error = <U as TryFrom<T>>::Error

The type returned in the event of a conversion error.

-
\ No newline at end of file +

impl<'a> StructuralEq for Slice<'a>[src]

impl<'a> StructuralPartialEq for Slice<'a>[src]

Auto Trait Implementations

impl<'a> Send for Slice<'a>

impl<'a> Sync for Slice<'a>

impl<'a> Unpin for Slice<'a>

Blanket Implementations

impl<T> Any for T where
    T: 'static + ?Sized, [src]

impl<T> Borrow<T> for T where
    T: ?Sized, [src]

impl<T> BorrowMut<T> for T where
    T: ?Sized, [src]

impl<T> From<T> for T[src]

impl<T, U> Into<U> for T where
    U: From<T>, [src]

impl<T, U> TryFrom<U> for T where
    U: Into<T>, [src]

type Error = Infallible

The type returned in the event of a conversion error.

+

impl<T, U> TryInto<U> for T where
    U: TryFrom<T>, [src]

type Error = <U as TryFrom<T>>::Error

The type returned in the event of a conversion error.

+
+ \ No newline at end of file diff --git a/flexiber/struct.Tag.html b/flexiber/struct.Tag.html index 059b270..82a16e5 100644 --- a/flexiber/struct.Tag.html +++ b/flexiber/struct.Tag.html @@ -1,14 +1,14 @@ -flexiber::Tag - Rust +flexiber::Tag - Rust -

[−][src]Struct flexiber::Tag

pub struct Tag {
+
Struct flexiber::Tag[−][src]
pub struct Tag {
     pub class: Class,
     pub constructed: bool,
     pub number: u16,
-}
The tag field consists of a single byte encoding a tag number from 1 to 254. The values '00' and 'FF' are invalid.

+}

The tag field consists of a single byte encoding a tag number from 1 to 254. The values ‘00’ and ‘FF’ are invalid.

Fields

class: Classconstructed: boolnumber: u16

Implementations

impl Tag[src]

pub const BOOLEAN: Self[src]

pub const INTEGER: Self[src]

pub const BIT_STRING: Self[src]

pub const OCTET_STRING: Self[src]

pub const NULL: Self[src]

pub const OBJECT_IDENTIFIER: Self[src]

pub const UTF8_STRING: Self[src]

pub const PRINTABLE_STRING: Self[src]

pub const UTC_TIME: Self[src]

pub const GENERALIZED_TIME: Self[src]

pub const SEQUENCE: Self[src]

pub const SET: Self[src]

pub fn from(class: Class, constructed: bool, number: u16) -> Self[src]

pub const fn universal(number: u16) -> Self[src]

pub const fn application(number: u16) -> Self[src]

pub const fn context(number: u16) -> Self[src]

pub const fn private(number: u16) -> Self[src]

pub const fn constructed(self) -> Self[src]

Trait Implementations

impl Clone for Tag[src]

impl Copy for Tag[src]

impl Debug for Tag[src]

impl Decodable<'_> for Tag[src]

impl TryFrom<u8> for Tag[src]

type Error = Error

The type returned in the event of a conversion error.

Auto Trait Implementations

impl Send for Tag[src]

impl Sync for Tag[src]

impl Unpin for Tag[src]

Blanket Implementations

impl<T> Any for T where
    T: 'static + ?Sized, [src]

impl<T> Borrow<T> for T where
    T: ?Sized, [src]

impl<T> BorrowMut<T> for T where
    T: ?Sized, [src]

impl<T> From<T> for T[src]

impl<T, U> Into<U> for T where
    U: From<T>, [src]

impl<T, U> TryFrom<U> for T where
    U: Into<T>, [src]

type Error = Infallible

The type returned in the event of a conversion error.

-

impl<T, U> TryInto<U> for T where
    U: TryFrom<T>, [src]

type Error = <U as TryFrom<T>>::Error

The type returned in the event of a conversion error.

-
\ No newline at end of file +

Auto Trait Implementations

impl Send for Tag

impl Sync for Tag

impl Unpin for Tag

Blanket Implementations

impl<T> Any for T where
    T: 'static + ?Sized, [src]

impl<T> Borrow<T> for T where
    T: ?Sized, [src]

impl<T> BorrowMut<T> for T where
    T: ?Sized, [src]

impl<T> From<T> for T[src]

impl<T, U> Into<U> for T where
    U: From<T>, [src]

impl<T, U> TryFrom<U> for T where
    U: Into<T>, [src]

type Error = Infallible

The type returned in the event of a conversion error.

+

impl<T, U> TryInto<U> for T where
    U: TryFrom<T>, [src]

type Error = <U as TryFrom<T>>::Error

The type returned in the event of a conversion error.

+
+ \ No newline at end of file diff --git a/flexiber/struct.TaggedValue.html b/flexiber/struct.TaggedValue.html index 5ff3d8c..5992e0a 100644 --- a/flexiber/struct.TaggedValue.html +++ b/flexiber/struct.TaggedValue.html @@ -1,16 +1,16 @@ -flexiber::TaggedValue - Rust +flexiber::TaggedValue - Rust -

[−][src]Struct flexiber::TaggedValue

pub struct TaggedValue<V, T = Tag> { /* fields omitted */ }

BER-TLV data object.

+

Struct flexiber::TaggedValue[−][src]

pub struct TaggedValue<V, T = Tag> { /* fields omitted */ }

BER-TLV data object.

Implementations

impl<V, T> TaggedValue<V, T> where
    T: Copy, [src]

pub fn new(tag: T, value: V) -> Self[src]

pub fn tag(&self) -> T[src]

impl<'a, T> TaggedValue<Slice<'a>, T> where
    T: Copy, [src]

pub fn from(tag: T, slice: &'a [u8]) -> Result<Self>[src]

Create a new tagged slice, checking lengths.

pub fn as_bytes(&self) -> &'a [u8][src]

Borrow the inner byte slice.

pub fn length(&self) -> Length[src]

Get the length of the inner byte slice.

pub fn is_empty(&self) -> bool[src]

Is the inner byte slice empty?

pub fn decode_nested<F, R>(&self, f: F) -> Result<R> where
    F: FnOnce(&mut Decoder<'a>) -> Result<R>, [src]

Decode nested values, creating a new Decoder for -the data contained in the sequence's body and passing it to the provided +the data contained in the sequence’s body and passing it to the provided FnOnce.

Trait Implementations

impl<V: Clone, T: Clone> Clone for TaggedValue<V, T>[src]

impl<V: Copy, T: Copy> Copy for TaggedValue<V, T>[src]

impl<V: Debug, T: Debug> Debug for TaggedValue<V, T>[src]

impl<'a, E, T> Encodable for TaggedValue<&'a E, T> where
    E: Encodable,
    T: Copy + Encodable, [src]

Auto Trait Implementations

impl<V, T> Send for TaggedValue<V, T> where
    T: Send,
    V: Send, [src]

impl<V, T> Sync for TaggedValue<V, T> where
    T: Sync,
    V: Sync, [src]

impl<V, T> Unpin for TaggedValue<V, T> where
    T: Unpin,
    V: Unpin, [src]

Blanket Implementations

impl<T> Any for T where
    T: 'static + ?Sized, [src]

impl<T> Borrow<T> for T where
    T: ?Sized, [src]

impl<T> BorrowMut<T> for T where
    T: ?Sized, [src]

impl<T> From<T> for T[src]

impl<T, U> Into<U> for T where
    U: From<T>, [src]

impl<T, U> TryFrom<U> for T where
    U: Into<T>, [src]

type Error = Infallible

The type returned in the event of a conversion error.

-

impl<T, U> TryInto<U> for T where
    U: TryFrom<T>, [src]

type Error = <U as TryFrom<T>>::Error

The type returned in the event of a conversion error.

-
\ No newline at end of file +

impl<V, T> StructuralEq for TaggedValue<V, T>[src]

impl<V, T> StructuralPartialEq for TaggedValue<V, T>[src]

Auto Trait Implementations

impl<V, T> Send for TaggedValue<V, T> where
    T: Send,
    V: Send, 

impl<V, T> Sync for TaggedValue<V, T> where
    T: Sync,
    V: Sync, 

impl<V, T> Unpin for TaggedValue<V, T> where
    T: Unpin,
    V: Unpin, 

Blanket Implementations

impl<T> Any for T where
    T: 'static + ?Sized, [src]

impl<T> Borrow<T> for T where
    T: ?Sized, [src]

impl<T> BorrowMut<T> for T where
    T: ?Sized, [src]

impl<T> From<T> for T[src]

impl<T, U> Into<U> for T where
    U: From<T>, [src]

impl<T, U> TryFrom<U> for T where
    U: Into<T>, [src]

type Error = Infallible

The type returned in the event of a conversion error.

+

impl<T, U> TryInto<U> for T where
    U: TryFrom<T>, [src]

type Error = <U as TryFrom<T>>::Error

The type returned in the event of a conversion error.

+
+ \ No newline at end of file diff --git a/flexiber/trait.Container.html b/flexiber/trait.Container.html index 636914a..41899ca 100644 --- a/flexiber/trait.Container.html +++ b/flexiber/trait.Container.html @@ -1,13 +1,14 @@ -flexiber::Container - Rust +flexiber::Container - Rust -

[−][src]Trait flexiber::Container

pub trait Container {
+
Trait flexiber::Container[−][src]
pub trait Container {
     fn fields<F, T>(&self, f: F) -> Result<T>
    where
        F: FnOnce(&[&dyn Encodable]) -> Result<T>;
 }
Multiple encodables in a container.

 
A container implementing Tagged has a blanked implementation of Encodable.

 
Required methods
fn fields<F, T>(&self, f: F) -> Result<T> where
    F: FnOnce(&[&dyn Encodable]) -> Result<T>, [src]
Call the provided function with a slice of Encodable trait objects
 representing the fields of this message.

-
This method uses a callback because structs with fields which aren't
+
This method uses a callback because structs with fields which aren’t
 directly Encodable may need to construct temporary values from
 their fields prior to encoding.

-
Loading content...
Implementors
Loading content...

\ No newline at end of file
+
Loading content...

Implementors

Loading content...
+ \ No newline at end of file diff --git a/flexiber/trait.Decodable.html b/flexiber/trait.Decodable.html index 91289a1..8b57271 100644 --- a/flexiber/trait.Decodable.html +++ b/flexiber/trait.Decodable.html @@ -1,7 +1,7 @@ -flexiber::Decodable - Rust +flexiber::Decodable - Rust -

[−][src]Trait flexiber::Decodable

pub trait Decodable<'a>: Sized {
+
Trait flexiber::Decodable[−][src]
pub trait Decodable<'a>: Sized {
     fn decode(decoder: &mut Decoder<'a>) -> Result<Self>;
 
     fn from_bytes(bytes: &'a [u8]) -> Result<Self> { ... }
@@ -12,4 +12,5 @@
Loading content...

Provided methods

fn from_bytes(bytes: &'a [u8]) -> Result<Self>[src]

Parse Self from the provided byte slice.

Loading content...

Implementations on Foreign Types

impl<'a, T> Decodable<'a> for Option<T> where
    T: Decodable<'a> + Tagged, [src]

This implementation is quite gotcha-y, since only one byte is peeked.

It should evaluate to the desired tag via Tag::try_from(byte)?.

-
Loading content...

Implementors

impl Decodable<'_> for Length[src]

impl Decodable<'_> for SimpleTag[src]

impl Decodable<'_> for Tag[src]

impl Decodable<'_> for [u8; 0][src]

impl Decodable<'_> for [u8; 1][src]

impl Decodable<'_> for [u8; 2][src]

impl Decodable<'_> for [u8; 3][src]

impl Decodable<'_> for [u8; 4][src]

impl Decodable<'_> for [u8; 5][src]

impl Decodable<'_> for [u8; 6][src]

impl Decodable<'_> for [u8; 7][src]

impl Decodable<'_> for [u8; 8][src]

impl Decodable<'_> for [u8; 9][src]

impl Decodable<'_> for [u8; 10][src]

impl Decodable<'_> for [u8; 11][src]

impl Decodable<'_> for [u8; 12][src]

impl Decodable<'_> for [u8; 13][src]

impl Decodable<'_> for [u8; 14][src]

impl Decodable<'_> for [u8; 15][src]

impl Decodable<'_> for [u8; 16][src]

impl Decodable<'_> for [u8; 17][src]

impl Decodable<'_> for [u8; 18][src]

impl Decodable<'_> for [u8; 19][src]

impl Decodable<'_> for [u8; 20][src]

impl Decodable<'_> for [u8; 21][src]

impl Decodable<'_> for [u8; 22][src]

impl Decodable<'_> for [u8; 23][src]

impl Decodable<'_> for [u8; 24][src]

impl Decodable<'_> for [u8; 25][src]

impl Decodable<'_> for [u8; 26][src]

impl Decodable<'_> for [u8; 27][src]

impl Decodable<'_> for [u8; 28][src]

impl Decodable<'_> for [u8; 29][src]

impl Decodable<'_> for [u8; 30][src]

impl Decodable<'_> for [u8; 31][src]

impl Decodable<'_> for [u8; 32][src]

impl<'a, T> Decodable<'a> for TaggedSlice<'a, T> where
    T: Decodable<'a> + TagLike, [src]

impl<'a, X> Decodable<'a> for X where
    X: TryFrom<TaggedSlice<'a>, Error = Error>, [src]

Loading content...
\ No newline at end of file +
Loading content...

Implementors

impl Decodable<'_> for Length[src]

impl Decodable<'_> for SimpleTag[src]

impl Decodable<'_> for Tag[src]

impl Decodable<'_> for [u8; 0][src]

impl Decodable<'_> for [u8; 1][src]

impl Decodable<'_> for [u8; 2][src]

impl Decodable<'_> for [u8; 3][src]

impl Decodable<'_> for [u8; 4][src]

impl Decodable<'_> for [u8; 5][src]

impl Decodable<'_> for [u8; 6][src]

impl Decodable<'_> for [u8; 7][src]

impl Decodable<'_> for [u8; 8][src]

impl Decodable<'_> for [u8; 9][src]

impl Decodable<'_> for [u8; 10][src]

impl Decodable<'_> for [u8; 11][src]

impl Decodable<'_> for [u8; 12][src]

impl Decodable<'_> for [u8; 13][src]

impl Decodable<'_> for [u8; 14][src]

impl Decodable<'_> for [u8; 15][src]

impl Decodable<'_> for [u8; 16][src]

impl Decodable<'_> for [u8; 17][src]

impl Decodable<'_> for [u8; 18][src]

impl Decodable<'_> for [u8; 19][src]

impl Decodable<'_> for [u8; 20][src]

impl Decodable<'_> for [u8; 21][src]

impl Decodable<'_> for [u8; 22][src]

impl Decodable<'_> for [u8; 23][src]

impl Decodable<'_> for [u8; 24][src]

impl Decodable<'_> for [u8; 25][src]

impl Decodable<'_> for [u8; 26][src]

impl Decodable<'_> for [u8; 27][src]

impl Decodable<'_> for [u8; 28][src]

impl Decodable<'_> for [u8; 29][src]

impl Decodable<'_> for [u8; 30][src]

impl Decodable<'_> for [u8; 31][src]

impl Decodable<'_> for [u8; 32][src]

impl<'a, T> Decodable<'a> for TaggedSlice<'a, T> where
    T: Decodable<'a> + TagLike, [src]

impl<'a, X> Decodable<'a> for X where
    X: TryFrom<TaggedSlice<'a>, Error = Error>, [src]

Loading content...
+ \ No newline at end of file diff --git a/flexiber/trait.Encodable.html b/flexiber/trait.Encodable.html index a97299e..e2be3b4 100644 --- a/flexiber/trait.Encodable.html +++ b/flexiber/trait.Encodable.html @@ -1,7 +1,7 @@ -flexiber::Encodable - Rust +flexiber::Encodable - Rust -

[−][src]Trait flexiber::Encodable

pub trait Encodable {
+
Trait flexiber::Encodable[−][src]
pub trait Encodable {
     fn encoded_length(&self) -> Result<Length>;
 
    fn encode(&self, encoder: &mut Encoder<'_>) -> Result<()>;
 
@@ -14,38 +14,39 @@
Loading content...

Provided methods

fn encode_to_slice<'a>(&self, buf: &'a mut [u8]) -> Result<&'a [u8]>[src]

Encode this value to the provided byte slice, returning a sub-slice containing the encoded message.

Loading content...

Implementations on Foreign Types

impl<T> Encodable for Option<T> where
    T: Encodable, [src]

fn encode(&self, encoder: &mut Encoder<'_>) -> Result<()>[src]

Encode this value as BER-TLV using the provided Encoder.

-
Loading content...

Implementors

impl Encodable for &[u8][src]

fn encode(&self, encoder: &mut Encoder<'_>) -> Result<()>[src]

Encode this value as BER-TLV using the provided Encoder.

-

impl Encodable for Length[src]

impl Encodable for SimpleTag[src]

impl Encodable for Tag[src]

impl Encodable for [u8; 0][src]

fn encode(&self, encoder: &mut Encoder<'_>) -> Result<()>[src]

Encode this value as BER-TLV using the provided Encoder.

-

impl Encodable for [u8; 1][src]

fn encode(&self, encoder: &mut Encoder<'_>) -> Result<()>[src]

Encode this value as BER-TLV using the provided Encoder.

-

impl Encodable for [u8; 2][src]

fn encode(&self, encoder: &mut Encoder<'_>) -> Result<()>[src]

Encode this value as BER-TLV using the provided Encoder.

-

impl Encodable for [u8; 3][src]

fn encode(&self, encoder: &mut Encoder<'_>) -> Result<()>[src]

Encode this value as BER-TLV using the provided Encoder.

-

impl Encodable for [u8; 4][src]

fn encode(&self, encoder: &mut Encoder<'_>) -> Result<()>[src]

Encode this value as BER-TLV using the provided Encoder.

-

impl Encodable for [u8; 5][src]

fn encode(&self, encoder: &mut Encoder<'_>) -> Result<()>[src]

Encode this value as BER-TLV using the provided Encoder.

-

impl Encodable for [u8; 6][src]

fn encode(&self, encoder: &mut Encoder<'_>) -> Result<()>[src]

Encode this value as BER-TLV using the provided Encoder.

-

impl Encodable for [u8; 7][src]

fn encode(&self, encoder: &mut Encoder<'_>) -> Result<()>[src]

Encode this value as BER-TLV using the provided Encoder.

-

impl Encodable for [u8; 8][src]

fn encode(&self, encoder: &mut Encoder<'_>) -> Result<()>[src]

Encode this value as BER-TLV using the provided Encoder.

-

impl Encodable for [u8; 9][src]

fn encode(&self, encoder: &mut Encoder<'_>) -> Result<()>[src]

Encode this value as BER-TLV using the provided Encoder.

-

impl Encodable for [u8; 10][src]

fn encode(&self, encoder: &mut Encoder<'_>) -> Result<()>[src]

Encode this value as BER-TLV using the provided Encoder.

-

impl Encodable for [u8; 11][src]

fn encode(&self, encoder: &mut Encoder<'_>) -> Result<()>[src]

Encode this value as BER-TLV using the provided Encoder.

-

impl Encodable for [u8; 12][src]

fn encode(&self, encoder: &mut Encoder<'_>) -> Result<()>[src]

Encode this value as BER-TLV using the provided Encoder.

-

impl Encodable for [u8; 13][src]

fn encode(&self, encoder: &mut Encoder<'_>) -> Result<()>[src]

Encode this value as BER-TLV using the provided Encoder.

-

impl Encodable for [u8; 14][src]

fn encode(&self, encoder: &mut Encoder<'_>) -> Result<()>[src]

Encode this value as BER-TLV using the provided Encoder.

-

impl Encodable for [u8; 15][src]

fn encode(&self, encoder: &mut Encoder<'_>) -> Result<()>[src]

Encode this value as BER-TLV using the provided Encoder.

-

impl Encodable for [u8; 16][src]

fn encode(&self, encoder: &mut Encoder<'_>) -> Result<()>[src]

Encode this value as BER-TLV using the provided Encoder.

-

impl Encodable for [u8; 17][src]

fn encode(&self, encoder: &mut Encoder<'_>) -> Result<()>[src]

Encode this value as BER-TLV using the provided Encoder.

-

impl Encodable for [u8; 18][src]

fn encode(&self, encoder: &mut Encoder<'_>) -> Result<()>[src]

Encode this value as BER-TLV using the provided Encoder.

-

impl Encodable for [u8; 19][src]

fn encode(&self, encoder: &mut Encoder<'_>) -> Result<()>[src]

Encode this value as BER-TLV using the provided Encoder.

-

impl Encodable for [u8; 20][src]

fn encode(&self, encoder: &mut Encoder<'_>) -> Result<()>[src]

Encode this value as BER-TLV using the provided Encoder.

-

impl Encodable for [u8; 21][src]

fn encode(&self, encoder: &mut Encoder<'_>) -> Result<()>[src]

Encode this value as BER-TLV using the provided Encoder.

-

impl Encodable for [u8; 22][src]

fn encode(&self, encoder: &mut Encoder<'_>) -> Result<()>[src]

Encode this value as BER-TLV using the provided Encoder.

-

impl Encodable for [u8; 23][src]

fn encode(&self, encoder: &mut Encoder<'_>) -> Result<()>[src]

Encode this value as BER-TLV using the provided Encoder.

-

impl Encodable for [u8; 24][src]

fn encode(&self, encoder: &mut Encoder<'_>) -> Result<()>[src]

Encode this value as BER-TLV using the provided Encoder.

-

impl Encodable for [u8; 25][src]

fn encode(&self, encoder: &mut Encoder<'_>) -> Result<()>[src]

Encode this value as BER-TLV using the provided Encoder.

-

impl Encodable for [u8; 26][src]

fn encode(&self, encoder: &mut Encoder<'_>) -> Result<()>[src]

Encode this value as BER-TLV using the provided Encoder.

-

impl Encodable for [u8; 27][src]

fn encode(&self, encoder: &mut Encoder<'_>) -> Result<()>[src]

Encode this value as BER-TLV using the provided Encoder.

-

impl Encodable for [u8; 28][src]

fn encode(&self, encoder: &mut Encoder<'_>) -> Result<()>[src]

Encode this value as BER-TLV using the provided Encoder.

-

impl Encodable for [u8; 29][src]

fn encode(&self, encoder: &mut Encoder<'_>) -> Result<()>[src]

Encode this value as BER-TLV using the provided Encoder.

-

impl Encodable for [u8; 30][src]

fn encode(&self, encoder: &mut Encoder<'_>) -> Result<()>[src]

Encode this value as BER-TLV using the provided Encoder.

-

impl Encodable for [u8; 31][src]

fn encode(&self, encoder: &mut Encoder<'_>) -> Result<()>[src]

Encode this value as BER-TLV using the provided Encoder.

-

impl Encodable for [u8; 32][src]

fn encode(&self, encoder: &mut Encoder<'_>) -> Result<()>[src]

Encode this value as BER-TLV using the provided Encoder.

-

impl<'a, E, T> Encodable for TaggedValue<&'a E, T> where
    E: Encodable,
    T: Copy + Encodable, [src]

impl<'a, T> Encodable for TaggedSlice<'a, T> where
    T: Copy + Encodable, [src]

impl<TaggedContainer> Encodable for TaggedContainer where
    TaggedContainer: Tagged + Container, [src]

Loading content...
\ No newline at end of file +Loading content...

Implementors

impl Encodable for &[u8][src]

fn encode(&self, encoder: &mut Encoder<'_>) -> Result<()>[src]

Encode this value as BER-TLV using the provided Encoder.

+

impl Encodable for Length[src]

impl Encodable for SimpleTag[src]

impl Encodable for Tag[src]

impl Encodable for [u8; 0][src]

fn encode(&self, encoder: &mut Encoder<'_>) -> Result<()>[src]

Encode this value as BER-TLV using the provided Encoder.

+

impl Encodable for [u8; 1][src]

fn encode(&self, encoder: &mut Encoder<'_>) -> Result<()>[src]

Encode this value as BER-TLV using the provided Encoder.

+

impl Encodable for [u8; 2][src]

fn encode(&self, encoder: &mut Encoder<'_>) -> Result<()>[src]

Encode this value as BER-TLV using the provided Encoder.

+

impl Encodable for [u8; 3][src]

fn encode(&self, encoder: &mut Encoder<'_>) -> Result<()>[src]

Encode this value as BER-TLV using the provided Encoder.

+

impl Encodable for [u8; 4][src]

fn encode(&self, encoder: &mut Encoder<'_>) -> Result<()>[src]

Encode this value as BER-TLV using the provided Encoder.

+

impl Encodable for [u8; 5][src]

fn encode(&self, encoder: &mut Encoder<'_>) -> Result<()>[src]

Encode this value as BER-TLV using the provided Encoder.

+

impl Encodable for [u8; 6][src]

fn encode(&self, encoder: &mut Encoder<'_>) -> Result<()>[src]

Encode this value as BER-TLV using the provided Encoder.

+

impl Encodable for [u8; 7][src]

fn encode(&self, encoder: &mut Encoder<'_>) -> Result<()>[src]

Encode this value as BER-TLV using the provided Encoder.

+

impl Encodable for [u8; 8][src]

fn encode(&self, encoder: &mut Encoder<'_>) -> Result<()>[src]

Encode this value as BER-TLV using the provided Encoder.

+

impl Encodable for [u8; 9][src]

fn encode(&self, encoder: &mut Encoder<'_>) -> Result<()>[src]

Encode this value as BER-TLV using the provided Encoder.

+

impl Encodable for [u8; 10][src]

fn encode(&self, encoder: &mut Encoder<'_>) -> Result<()>[src]

Encode this value as BER-TLV using the provided Encoder.

+

impl Encodable for [u8; 11][src]

fn encode(&self, encoder: &mut Encoder<'_>) -> Result<()>[src]

Encode this value as BER-TLV using the provided Encoder.

+

impl Encodable for [u8; 12][src]

fn encode(&self, encoder: &mut Encoder<'_>) -> Result<()>[src]

Encode this value as BER-TLV using the provided Encoder.

+

impl Encodable for [u8; 13][src]

fn encode(&self, encoder: &mut Encoder<'_>) -> Result<()>[src]

Encode this value as BER-TLV using the provided Encoder.

+

impl Encodable for [u8; 14][src]

fn encode(&self, encoder: &mut Encoder<'_>) -> Result<()>[src]

Encode this value as BER-TLV using the provided Encoder.

+

impl Encodable for [u8; 15][src]

fn encode(&self, encoder: &mut Encoder<'_>) -> Result<()>[src]

Encode this value as BER-TLV using the provided Encoder.

+

impl Encodable for [u8; 16][src]

fn encode(&self, encoder: &mut Encoder<'_>) -> Result<()>[src]

Encode this value as BER-TLV using the provided Encoder.

+

impl Encodable for [u8; 17][src]

fn encode(&self, encoder: &mut Encoder<'_>) -> Result<()>[src]

Encode this value as BER-TLV using the provided Encoder.

+

impl Encodable for [u8; 18][src]

fn encode(&self, encoder: &mut Encoder<'_>) -> Result<()>[src]

Encode this value as BER-TLV using the provided Encoder.

+

impl Encodable for [u8; 19][src]

fn encode(&self, encoder: &mut Encoder<'_>) -> Result<()>[src]

Encode this value as BER-TLV using the provided Encoder.

+

impl Encodable for [u8; 20][src]

fn encode(&self, encoder: &mut Encoder<'_>) -> Result<()>[src]

Encode this value as BER-TLV using the provided Encoder.

+

impl Encodable for [u8; 21][src]

fn encode(&self, encoder: &mut Encoder<'_>) -> Result<()>[src]

Encode this value as BER-TLV using the provided Encoder.

+

impl Encodable for [u8; 22][src]

fn encode(&self, encoder: &mut Encoder<'_>) -> Result<()>[src]

Encode this value as BER-TLV using the provided Encoder.

+

impl Encodable for [u8; 23][src]

fn encode(&self, encoder: &mut Encoder<'_>) -> Result<()>[src]

Encode this value as BER-TLV using the provided Encoder.

+

impl Encodable for [u8; 24][src]

fn encode(&self, encoder: &mut Encoder<'_>) -> Result<()>[src]

Encode this value as BER-TLV using the provided Encoder.

+

impl Encodable for [u8; 25][src]

fn encode(&self, encoder: &mut Encoder<'_>) -> Result<()>[src]

Encode this value as BER-TLV using the provided Encoder.

+

impl Encodable for [u8; 26][src]

fn encode(&self, encoder: &mut Encoder<'_>) -> Result<()>[src]

Encode this value as BER-TLV using the provided Encoder.

+

impl Encodable for [u8; 27][src]

fn encode(&self, encoder: &mut Encoder<'_>) -> Result<()>[src]

Encode this value as BER-TLV using the provided Encoder.

+

impl Encodable for [u8; 28][src]

fn encode(&self, encoder: &mut Encoder<'_>) -> Result<()>[src]

Encode this value as BER-TLV using the provided Encoder.

+

impl Encodable for [u8; 29][src]

fn encode(&self, encoder: &mut Encoder<'_>) -> Result<()>[src]

Encode this value as BER-TLV using the provided Encoder.

+

impl Encodable for [u8; 30][src]

fn encode(&self, encoder: &mut Encoder<'_>) -> Result<()>[src]

Encode this value as BER-TLV using the provided Encoder.

+

impl Encodable for [u8; 31][src]

fn encode(&self, encoder: &mut Encoder<'_>) -> Result<()>[src]

Encode this value as BER-TLV using the provided Encoder.

+

impl Encodable for [u8; 32][src]

fn encode(&self, encoder: &mut Encoder<'_>) -> Result<()>[src]

Encode this value as BER-TLV using the provided Encoder.

+

impl<'a, E, T> Encodable for TaggedValue<&'a E, T> where
    E: Encodable,
    T: Copy + Encodable, [src]

impl<'a, T> Encodable for TaggedSlice<'a, T> where
    T: Copy + Encodable, [src]

impl<TaggedContainer> Encodable for TaggedContainer where
    TaggedContainer: Tagged + Container, [src]

Loading content...
+ \ No newline at end of file diff --git a/flexiber/trait.TagLike.html b/flexiber/trait.TagLike.html index 4f76362..f848ebb 100644 --- a/flexiber/trait.TagLike.html +++ b/flexiber/trait.TagLike.html @@ -1,7 +1,7 @@ -flexiber::TagLike - Rust +flexiber::TagLike - Rust -

[−][src]Trait flexiber::TagLike

pub trait TagLike: Copy + PartialEq + Sized {
+
Trait flexiber::TagLike[−][src]
pub trait TagLike: Copy + PartialEq + Sized {
     fn embedding(self) -> Tag;
 
     fn assert_eq(self, expected: Self) -> Result<Self> { ... }
@@ -13,4 +13,5 @@ or other be coerced into a BerTag.
Loading content...

Provided methods

fn assert_eq(self, expected: Self) -> Result<Self>[src]

Assert that this Tag matches the provided expected tag.

On mismatch, returns an Error with ErrorKind::UnexpectedTag.

fn with_value<V>(self, value: V) -> TaggedValue<V, Self>[src]

Ergonomic way to get a TaggedValue for a given tag and value

-
Loading content...

Implementors

impl TagLike for SimpleTag[src]

impl TagLike for Tag[src]

Loading content...
\ No newline at end of file +Loading content...

Implementors

Loading content...
+ \ No newline at end of file diff --git a/flexiber/trait.Tagged.html b/flexiber/trait.Tagged.html index 4fc68b1..4798f66 100644 --- a/flexiber/trait.Tagged.html +++ b/flexiber/trait.Tagged.html @@ -1,9 +1,10 @@ -flexiber::Tagged - Rust +flexiber::Tagged - Rust -

[−][src]Trait flexiber::Tagged

pub trait Tagged {
+
Trait flexiber::Tagged[−][src]
pub trait Tagged {
     fn tag() -> Tag;
 }
Types with an associated BER-TLV Tag.

 
A tagged type implementing Container has a blanked implementation of Encodable.

 
Required methods
fn tag() -> Tag[src]
The tag

-
Loading content...
Implementors
Loading content...

\ No newline at end of file
+
Loading content...

Implementors

Loading content...
+ \ No newline at end of file diff --git a/flexiber/type.Result.html b/flexiber/type.Result.html index 53a9f14..b0cc6e8 100644 --- a/flexiber/type.Result.html +++ b/flexiber/type.Result.html @@ -1,7 +1,8 @@ -flexiber::Result - Rust +flexiber::Result - Rust -

[−][src]Type Definition flexiber::Result

type Result<T> = Result<T, Error>;

Result type.

+

Type Definition flexiber::Result[−][src]

type Result<T> = Result<T, Error>;

Result type.

Trait Implementations

impl Add<Length> for Result<Length>[src]

type Output = Self

The resulting type after applying the + operator.

\ No newline at end of file +
+ \ No newline at end of file diff --git a/flexiber/type.TaggedSlice.html b/flexiber/type.TaggedSlice.html index 415b5a1..85cc666 100644 --- a/flexiber/type.TaggedSlice.html +++ b/flexiber/type.TaggedSlice.html @@ -1,13 +1,13 @@ -flexiber::TaggedSlice - Rust +flexiber::TaggedSlice - Rust -

[−][src]Type Definition flexiber::TaggedSlice

type TaggedSlice<'a, T = Tag> = TaggedValue<Slice<'a>, T>;

Raw BER-TLV data object TaggedValue<Slice<'_>>.

+

Type Definition flexiber::TaggedSlice[−][src]

type TaggedSlice<'a, T = Tag> = TaggedValue<Slice<'a>, T>;

Raw BER-TLV data object TaggedValue<Slice<'_>>.

Implementations

impl<'a, T> TaggedSlice<'a, T> where
    T: Copy, [src]

pub fn from(tag: T, slice: &'a [u8]) -> Result<Self>[src]

Create a new tagged slice, checking lengths.

pub fn as_bytes(&self) -> &'a [u8][src]

Borrow the inner byte slice.

pub fn length(&self) -> Length[src]

Get the length of the inner byte slice.

pub fn is_empty(&self) -> bool[src]

Is the inner byte slice empty?

pub fn decode_nested<F, R>(&self, f: F) -> Result<R> where
    F: FnOnce(&mut Decoder<'a>) -> Result<R>, [src]

Decode nested values, creating a new Decoder for -the data contained in the sequence's body and passing it to the provided +the data contained in the sequence’s body and passing it to the provided FnOnce.

Trait Implementations

impl<'a, T> Decodable<'a> for TaggedSlice<'a, T> where
    T: Decodable<'a> + TagLike, [src]

\ No newline at end of file +
+ \ No newline at end of file diff --git a/flexiber_derive/all.html b/flexiber_derive/all.html index 066dfe8..a7b58b6 100644 --- a/flexiber_derive/all.html +++ b/flexiber_derive/all.html @@ -1,6 +1,7 @@ -List of all items in this crate +List of all items in this crate -

[−] +

List of all items[−] - List of all items

Derive Macros

\ No newline at end of file +

Derive Macros

+ \ No newline at end of file diff --git a/flexiber_derive/derive.Decodable.html b/flexiber_derive/derive.Decodable.html index e0126b8..72202ed 100644 --- a/flexiber_derive/derive.Decodable.html +++ b/flexiber_derive/derive.Decodable.html @@ -1,11 +1,13 @@ -flexiber_derive::Decodable - Rust +flexiber_derive::Decodable - Rust -

[−][src]Derive Macro flexiber_derive::Decodable

#[derive(Decodable)]
+
Derive Macro flexiber_derive::Decodable[−][src]
#[derive(Decodable)]
 {
     // Attributes available to this derive:
     #[tlv]
-}
Derive the Decodable trait on a struct.

+}
+

Derive the Decodable trait on a struct.

See toplevel documentation for the flexiber_derive crate for more information about how to use this macro.

-
\ No newline at end of file +
+ \ No newline at end of file diff --git a/flexiber_derive/derive.Encodable.html b/flexiber_derive/derive.Encodable.html index 48942ba..4026d2e 100644 --- a/flexiber_derive/derive.Encodable.html +++ b/flexiber_derive/derive.Encodable.html @@ -1,11 +1,13 @@ -flexiber_derive::Encodable - Rust +flexiber_derive::Encodable - Rust -

[−][src]Derive Macro flexiber_derive::Encodable

#[derive(Encodable)]
+
Derive Macro flexiber_derive::Encodable[−][src]
#[derive(Encodable)]
 {
     // Attributes available to this derive:
     #[tlv]
-}
Derive the Encodable trait on a struct.

+}
+

Derive the Encodable trait on a struct.

See toplevel documentation for the flexiber_derive crate for more information about how to use this macro.

-
\ No newline at end of file +
+ \ No newline at end of file diff --git a/flexiber_derive/index.html b/flexiber_derive/index.html index 592c68e..6f28e63 100644 --- a/flexiber_derive/index.html +++ b/flexiber_derive/index.html @@ -1,11 +1,12 @@ -flexiber_derive - Rust +flexiber_derive - Rust -

[−][src]Crate flexiber_derive

Custom derive support for the flexiber crate

+

Crate flexiber_derive[−][src]

Custom derive support for the flexiber crate

With #[tlv(slice)] set, Encodable should work for fields implementing AsRef<[u8]>, and Decodable should work for fields implementing TryFrom<[u8]>, even if the field is not Decodable or Encodable.

Derive Macros

Decodable

Derive the Decodable trait on a struct.

Encodable

Derive the Encodable trait on a struct.

-
\ No newline at end of file +
+ \ No newline at end of file diff --git a/implementors/core/clone/trait.Clone.js b/implementors/core/clone/trait.Clone.js index e58c605..482483e 100644 --- a/implementors/core/clone/trait.Clone.js +++ b/implementors/core/clone/trait.Clone.js @@ -1,8 +1,8 @@ (function() {var implementors = {}; -implementors["delog"] = [{"text":"impl Clone for Statistics","synthetic":false,"types":[]},{"text":"impl Clone for DefaultRenderer","synthetic":false,"types":[]},{"text":"impl Clone for RipgrepRenderer","synthetic":false,"types":[]}]; -implementors["flexiber"] = [{"text":"impl Clone for Error","synthetic":false,"types":[]},{"text":"impl Clone for ErrorKind","synthetic":false,"types":[]},{"text":"impl Clone for Length","synthetic":false,"types":[]},{"text":"impl Clone for SimpleTag","synthetic":false,"types":[]},{"text":"impl<'a> Clone for Slice<'a>","synthetic":false,"types":[]},{"text":"impl Clone for Class","synthetic":false,"types":[]},{"text":"impl Clone for Tag","synthetic":false,"types":[]},{"text":"impl<V: Clone, T: Clone> Clone for TaggedValue<V, T>","synthetic":false,"types":[]}]; -implementors["log"] = [{"text":"impl Clone for Level","synthetic":false,"types":[]},{"text":"impl Clone for LevelFilter","synthetic":false,"types":[]},{"text":"impl<'a> Clone for Record<'a>","synthetic":false,"types":[]},{"text":"impl<'a> Clone for Metadata<'a>","synthetic":false,"types":[]}]; -implementors["proc_macro2"] = [{"text":"impl Clone for TokenStream","synthetic":false,"types":[]},{"text":"impl Clone for Span","synthetic":false,"types":[]},{"text":"impl Clone for TokenTree","synthetic":false,"types":[]},{"text":"impl Clone for Group","synthetic":false,"types":[]},{"text":"impl Clone for Delimiter","synthetic":false,"types":[]},{"text":"impl Clone for Punct","synthetic":false,"types":[]},{"text":"impl Clone for Spacing","synthetic":false,"types":[]},{"text":"impl Clone for Ident","synthetic":false,"types":[]},{"text":"impl Clone for Literal","synthetic":false,"types":[]},{"text":"impl Clone for IntoIter","synthetic":false,"types":[]}]; -implementors["syn"] = [{"text":"impl Clone for Underscore","synthetic":false,"types":[]},{"text":"impl Clone for Abstract","synthetic":false,"types":[]},{"text":"impl Clone for As","synthetic":false,"types":[]},{"text":"impl Clone for Async","synthetic":false,"types":[]},{"text":"impl Clone for Auto","synthetic":false,"types":[]},{"text":"impl Clone for Await","synthetic":false,"types":[]},{"text":"impl Clone for Become","synthetic":false,"types":[]},{"text":"impl Clone for Box","synthetic":false,"types":[]},{"text":"impl Clone for Break","synthetic":false,"types":[]},{"text":"impl Clone for Const","synthetic":false,"types":[]},{"text":"impl Clone for Continue","synthetic":false,"types":[]},{"text":"impl Clone for Crate","synthetic":false,"types":[]},{"text":"impl Clone for Default","synthetic":false,"types":[]},{"text":"impl Clone for Do","synthetic":false,"types":[]},{"text":"impl Clone for Dyn","synthetic":false,"types":[]},{"text":"impl Clone for Else","synthetic":false,"types":[]},{"text":"impl Clone for Enum","synthetic":false,"types":[]},{"text":"impl Clone for Extern","synthetic":false,"types":[]},{"text":"impl Clone for Final","synthetic":false,"types":[]},{"text":"impl Clone for Fn","synthetic":false,"types":[]},{"text":"impl Clone for For","synthetic":false,"types":[]},{"text":"impl Clone for If","synthetic":false,"types":[]},{"text":"impl Clone for Impl","synthetic":false,"types":[]},{"text":"impl Clone for In","synthetic":false,"types":[]},{"text":"impl Clone for Let","synthetic":false,"types":[]},{"text":"impl Clone for Loop","synthetic":false,"types":[]},{"text":"impl Clone for Macro","synthetic":false,"types":[]},{"text":"impl Clone for Match","synthetic":false,"types":[]},{"text":"impl Clone for Mod","synthetic":false,"types":[]},{"text":"impl Clone for Move","synthetic":false,"types":[]},{"text":"impl Clone for Mut","synthetic":false,"types":[]},{"text":"impl Clone for Override","synthetic":false,"types":[]},{"text":"impl Clone for Priv","synthetic":false,"types":[]},{"text":"impl Clone for Pub","synthetic":false,"types":[]},{"text":"impl Clone for Ref","synthetic":false,"types":[]},{"text":"impl Clone for Return","synthetic":false,"types":[]},{"text":"impl Clone for SelfType","synthetic":false,"types":[]},{"text":"impl Clone for SelfValue","synthetic":false,"types":[]},{"text":"impl Clone for Static","synthetic":false,"types":[]},{"text":"impl Clone for Struct","synthetic":false,"types":[]},{"text":"impl Clone for Super","synthetic":false,"types":[]},{"text":"impl Clone for Trait","synthetic":false,"types":[]},{"text":"impl Clone for Try","synthetic":false,"types":[]},{"text":"impl Clone for Type","synthetic":false,"types":[]},{"text":"impl Clone for Typeof","synthetic":false,"types":[]},{"text":"impl Clone for Union","synthetic":false,"types":[]},{"text":"impl Clone for Unsafe","synthetic":false,"types":[]},{"text":"impl Clone for Unsized","synthetic":false,"types":[]},{"text":"impl Clone for Use","synthetic":false,"types":[]},{"text":"impl Clone for Virtual","synthetic":false,"types":[]},{"text":"impl Clone for Where","synthetic":false,"types":[]},{"text":"impl Clone for While","synthetic":false,"types":[]},{"text":"impl Clone for Yield","synthetic":false,"types":[]},{"text":"impl Clone for Add","synthetic":false,"types":[]},{"text":"impl Clone for AddEq","synthetic":false,"types":[]},{"text":"impl Clone for And","synthetic":false,"types":[]},{"text":"impl Clone for AndAnd","synthetic":false,"types":[]},{"text":"impl Clone for AndEq","synthetic":false,"types":[]},{"text":"impl Clone for At","synthetic":false,"types":[]},{"text":"impl Clone for Bang","synthetic":false,"types":[]},{"text":"impl Clone for Caret","synthetic":false,"types":[]},{"text":"impl Clone for CaretEq","synthetic":false,"types":[]},{"text":"impl Clone for Colon","synthetic":false,"types":[]},{"text":"impl Clone for Colon2","synthetic":false,"types":[]},{"text":"impl Clone for Comma","synthetic":false,"types":[]},{"text":"impl Clone for Div","synthetic":false,"types":[]},{"text":"impl Clone for DivEq","synthetic":false,"types":[]},{"text":"impl Clone for Dollar","synthetic":false,"types":[]},{"text":"impl Clone for Dot","synthetic":false,"types":[]},{"text":"impl Clone for Dot2","synthetic":false,"types":[]},{"text":"impl Clone for Dot3","synthetic":false,"types":[]},{"text":"impl Clone for DotDotEq","synthetic":false,"types":[]},{"text":"impl Clone for Eq","synthetic":false,"types":[]},{"text":"impl Clone for EqEq","synthetic":false,"types":[]},{"text":"impl Clone for Ge","synthetic":false,"types":[]},{"text":"impl Clone for Gt","synthetic":false,"types":[]},{"text":"impl Clone for Le","synthetic":false,"types":[]},{"text":"impl Clone for Lt","synthetic":false,"types":[]},{"text":"impl Clone for MulEq","synthetic":false,"types":[]},{"text":"impl Clone for Ne","synthetic":false,"types":[]},{"text":"impl Clone for Or","synthetic":false,"types":[]},{"text":"impl Clone for OrEq","synthetic":false,"types":[]},{"text":"impl Clone for OrOr","synthetic":false,"types":[]},{"text":"impl Clone for Pound","synthetic":false,"types":[]},{"text":"impl Clone for Question","synthetic":false,"types":[]},{"text":"impl Clone for RArrow","synthetic":false,"types":[]},{"text":"impl Clone for LArrow","synthetic":false,"types":[]},{"text":"impl Clone for Rem","synthetic":false,"types":[]},{"text":"impl Clone for RemEq","synthetic":false,"types":[]},{"text":"impl Clone for FatArrow","synthetic":false,"types":[]},{"text":"impl Clone for Semi","synthetic":false,"types":[]},{"text":"impl Clone for Shl","synthetic":false,"types":[]},{"text":"impl Clone for ShlEq","synthetic":false,"types":[]},{"text":"impl Clone for Shr","synthetic":false,"types":[]},{"text":"impl Clone for ShrEq","synthetic":false,"types":[]},{"text":"impl Clone for Star","synthetic":false,"types":[]},{"text":"impl Clone for Sub","synthetic":false,"types":[]},{"text":"impl Clone for SubEq","synthetic":false,"types":[]},{"text":"impl Clone for Tilde","synthetic":false,"types":[]},{"text":"impl Clone for Brace","synthetic":false,"types":[]},{"text":"impl Clone for Bracket","synthetic":false,"types":[]},{"text":"impl Clone for Paren","synthetic":false,"types":[]},{"text":"impl Clone for Group","synthetic":false,"types":[]},{"text":"impl<'a> Clone for ImplGenerics<'a>","synthetic":false,"types":[]},{"text":"impl<'a> Clone for TypeGenerics<'a>","synthetic":false,"types":[]},{"text":"impl<'a> Clone for Turbofish<'a>","synthetic":false,"types":[]},{"text":"impl Clone for Lifetime","synthetic":false,"types":[]},{"text":"impl Clone for LitStr","synthetic":false,"types":[]},{"text":"impl Clone for LitByteStr","synthetic":false,"types":[]},{"text":"impl Clone for LitByte","synthetic":false,"types":[]},{"text":"impl Clone for LitChar","synthetic":false,"types":[]},{"text":"impl Clone for LitInt","synthetic":false,"types":[]},{"text":"impl Clone for LitFloat","synthetic":false,"types":[]},{"text":"impl<'a> Clone for Cursor<'a>","synthetic":false,"types":[]},{"text":"impl<T, P> Clone for Punctuated<T, P> where
    T: Clone,
    P: Clone, ","synthetic":false,"types":[]},{"text":"impl<'a, T, P> Clone for Pairs<'a, T, P>","synthetic":false,"types":[]},{"text":"impl<T, P> Clone for IntoPairs<T, P> where
    T: Clone,
    P: Clone, ","synthetic":false,"types":[]},{"text":"impl<T> Clone for IntoIter<T> where
    T: Clone, ","synthetic":false,"types":[]},{"text":"impl<'a, T> Clone for Iter<'a, T>","synthetic":false,"types":[]},{"text":"impl<T, P> Clone for Pair<T, P> where
    T: Clone,
    P: Clone, ","synthetic":false,"types":[]},{"text":"impl Clone for Abi","synthetic":false,"types":[]},{"text":"impl Clone for AngleBracketedGenericArguments","synthetic":false,"types":[]},{"text":"impl Clone for AttrStyle","synthetic":false,"types":[]},{"text":"impl Clone for Attribute","synthetic":false,"types":[]},{"text":"impl Clone for BareFnArg","synthetic":false,"types":[]},{"text":"impl Clone for BinOp","synthetic":false,"types":[]},{"text":"impl Clone for Binding","synthetic":false,"types":[]},{"text":"impl Clone for BoundLifetimes","synthetic":false,"types":[]},{"text":"impl Clone for ConstParam","synthetic":false,"types":[]},{"text":"impl Clone for Constraint","synthetic":false,"types":[]},{"text":"impl Clone for Data","synthetic":false,"types":[]},{"text":"impl Clone for DataEnum","synthetic":false,"types":[]},{"text":"impl Clone for DataStruct","synthetic":false,"types":[]},{"text":"impl Clone for DataUnion","synthetic":false,"types":[]},{"text":"impl Clone for DeriveInput","synthetic":false,"types":[]},{"text":"impl Clone for Expr","synthetic":false,"types":[]},{"text":"impl Clone for ExprBinary","synthetic":false,"types":[]},{"text":"impl Clone for ExprCall","synthetic":false,"types":[]},{"text":"impl Clone for ExprCast","synthetic":false,"types":[]},{"text":"impl Clone for ExprField","synthetic":false,"types":[]},{"text":"impl Clone for ExprIndex","synthetic":false,"types":[]},{"text":"impl Clone for ExprLit","synthetic":false,"types":[]},{"text":"impl Clone for ExprParen","synthetic":false,"types":[]},{"text":"impl Clone for ExprPath","synthetic":false,"types":[]},{"text":"impl Clone for ExprUnary","synthetic":false,"types":[]},{"text":"impl Clone for Field","synthetic":false,"types":[]},{"text":"impl Clone for Fields","synthetic":false,"types":[]},{"text":"impl Clone for FieldsNamed","synthetic":false,"types":[]},{"text":"impl Clone for FieldsUnnamed","synthetic":false,"types":[]},{"text":"impl Clone for GenericArgument","synthetic":false,"types":[]},{"text":"impl Clone for GenericParam","synthetic":false,"types":[]},{"text":"impl Clone for Generics","synthetic":false,"types":[]},{"text":"impl Clone for Index","synthetic":false,"types":[]},{"text":"impl Clone for LifetimeDef","synthetic":false,"types":[]},{"text":"impl Clone for Lit","synthetic":false,"types":[]},{"text":"impl Clone for LitBool","synthetic":false,"types":[]},{"text":"impl Clone for Macro","synthetic":false,"types":[]},{"text":"impl Clone for MacroDelimiter","synthetic":false,"types":[]},{"text":"impl Clone for Member","synthetic":false,"types":[]},{"text":"impl Clone for Meta","synthetic":false,"types":[]},{"text":"impl Clone for MetaList","synthetic":false,"types":[]},{"text":"impl Clone for MetaNameValue","synthetic":false,"types":[]},{"text":"impl Clone for NestedMeta","synthetic":false,"types":[]},{"text":"impl Clone for ParenthesizedGenericArguments","synthetic":false,"types":[]},{"text":"impl Clone for Path","synthetic":false,"types":[]},{"text":"impl Clone for PathArguments","synthetic":false,"types":[]},{"text":"impl Clone for PathSegment","synthetic":false,"types":[]},{"text":"impl Clone for PredicateEq","synthetic":false,"types":[]},{"text":"impl Clone for PredicateLifetime","synthetic":false,"types":[]},{"text":"impl Clone for PredicateType","synthetic":false,"types":[]},{"text":"impl Clone for QSelf","synthetic":false,"types":[]},{"text":"impl Clone for ReturnType","synthetic":false,"types":[]},{"text":"impl Clone for TraitBound","synthetic":false,"types":[]},{"text":"impl Clone for TraitBoundModifier","synthetic":false,"types":[]},{"text":"impl Clone for Type","synthetic":false,"types":[]},{"text":"impl Clone for TypeArray","synthetic":false,"types":[]},{"text":"impl Clone for TypeBareFn","synthetic":false,"types":[]},{"text":"impl Clone for TypeGroup","synthetic":false,"types":[]},{"text":"impl Clone for TypeImplTrait","synthetic":false,"types":[]},{"text":"impl Clone for TypeInfer","synthetic":false,"types":[]},{"text":"impl Clone for TypeMacro","synthetic":false,"types":[]},{"text":"impl Clone for TypeNever","synthetic":false,"types":[]},{"text":"impl Clone for TypeParam","synthetic":false,"types":[]},{"text":"impl Clone for TypeParamBound","synthetic":false,"types":[]},{"text":"impl Clone for TypeParen","synthetic":false,"types":[]},{"text":"impl Clone for TypePath","synthetic":false,"types":[]},{"text":"impl Clone for TypePtr","synthetic":false,"types":[]},{"text":"impl Clone for TypeReference","synthetic":false,"types":[]},{"text":"impl Clone for TypeSlice","synthetic":false,"types":[]},{"text":"impl Clone for TypeTraitObject","synthetic":false,"types":[]},{"text":"impl Clone for TypeTuple","synthetic":false,"types":[]},{"text":"impl Clone for UnOp","synthetic":false,"types":[]},{"text":"impl Clone for Variadic","synthetic":false,"types":[]},{"text":"impl Clone for Variant","synthetic":false,"types":[]},{"text":"impl Clone for VisCrate","synthetic":false,"types":[]},{"text":"impl Clone for VisPublic","synthetic":false,"types":[]},{"text":"impl Clone for VisRestricted","synthetic":false,"types":[]},{"text":"impl Clone for Visibility","synthetic":false,"types":[]},{"text":"impl Clone for WhereClause","synthetic":false,"types":[]},{"text":"impl Clone for WherePredicate","synthetic":false,"types":[]},{"text":"impl<'c, 'a> Clone for StepCursor<'c, 'a>","synthetic":false,"types":[]},{"text":"impl Clone for Error","synthetic":false,"types":[]}]; -implementors["synstructure"] = [{"text":"impl Clone for AddBounds","synthetic":false,"types":[]},{"text":"impl Clone for BindStyle","synthetic":false,"types":[]},{"text":"impl<'a> Clone for BindingInfo<'a>","synthetic":false,"types":[]},{"text":"impl<'a> Clone for VariantAst<'a>","synthetic":false,"types":[]},{"text":"impl<'a> Clone for VariantInfo<'a>","synthetic":false,"types":[]},{"text":"impl<'a> Clone for Structure<'a>","synthetic":false,"types":[]}]; +implementors["delog"] = [{"text":"impl Clone for Statistics","synthetic":false,"types":["delog::logger::Statistics"]},{"text":"impl Clone for DefaultRenderer","synthetic":false,"types":["delog::render::DefaultRenderer"]},{"text":"impl Clone for RipgrepRenderer","synthetic":false,"types":["delog::render::RipgrepRenderer"]}]; +implementors["flexiber"] = [{"text":"impl Clone for Error","synthetic":false,"types":["flexiber::error::Error"]},{"text":"impl Clone for ErrorKind","synthetic":false,"types":["flexiber::error::ErrorKind"]},{"text":"impl Clone for Length","synthetic":false,"types":["flexiber::length::Length"]},{"text":"impl Clone for SimpleTag","synthetic":false,"types":["flexiber::simpletag::SimpleTag"]},{"text":"impl<'a> Clone for Slice<'a>","synthetic":false,"types":["flexiber::slice::Slice"]},{"text":"impl Clone for Class","synthetic":false,"types":["flexiber::tag::Class"]},{"text":"impl Clone for Tag","synthetic":false,"types":["flexiber::tag::Tag"]},{"text":"impl<V: Clone, T: Clone> Clone for TaggedValue<V, T>","synthetic":false,"types":["flexiber::tagged::TaggedValue"]}]; +implementors["log"] = [{"text":"impl Clone for Level","synthetic":false,"types":["log::Level"]},{"text":"impl Clone for LevelFilter","synthetic":false,"types":["log::LevelFilter"]},{"text":"impl<'a> Clone for Record<'a>","synthetic":false,"types":["log::Record"]},{"text":"impl<'a> Clone for Metadata<'a>","synthetic":false,"types":["log::Metadata"]}]; +implementors["proc_macro2"] = [{"text":"impl Clone for TokenStream","synthetic":false,"types":["proc_macro2::TokenStream"]},{"text":"impl Clone for Span","synthetic":false,"types":["proc_macro2::Span"]},{"text":"impl Clone for TokenTree","synthetic":false,"types":["proc_macro2::TokenTree"]},{"text":"impl Clone for Group","synthetic":false,"types":["proc_macro2::Group"]},{"text":"impl Clone for Delimiter","synthetic":false,"types":["proc_macro2::Delimiter"]},{"text":"impl Clone for Punct","synthetic":false,"types":["proc_macro2::Punct"]},{"text":"impl Clone for Spacing","synthetic":false,"types":["proc_macro2::Spacing"]},{"text":"impl Clone for Ident","synthetic":false,"types":["proc_macro2::Ident"]},{"text":"impl Clone for Literal","synthetic":false,"types":["proc_macro2::Literal"]},{"text":"impl Clone for IntoIter","synthetic":false,"types":["proc_macro2::token_stream::IntoIter"]}]; +implementors["syn"] = [{"text":"impl Clone for Underscore","synthetic":false,"types":["syn::token::Underscore"]},{"text":"impl Clone for Abstract","synthetic":false,"types":["syn::token::Abstract"]},{"text":"impl Clone for As","synthetic":false,"types":["syn::token::As"]},{"text":"impl Clone for Async","synthetic":false,"types":["syn::token::Async"]},{"text":"impl Clone for Auto","synthetic":false,"types":["syn::token::Auto"]},{"text":"impl Clone for Await","synthetic":false,"types":["syn::token::Await"]},{"text":"impl Clone for Become","synthetic":false,"types":["syn::token::Become"]},{"text":"impl Clone for Box","synthetic":false,"types":["syn::token::Box"]},{"text":"impl Clone for Break","synthetic":false,"types":["syn::token::Break"]},{"text":"impl Clone for Const","synthetic":false,"types":["syn::token::Const"]},{"text":"impl Clone for Continue","synthetic":false,"types":["syn::token::Continue"]},{"text":"impl Clone for Crate","synthetic":false,"types":["syn::token::Crate"]},{"text":"impl Clone for Default","synthetic":false,"types":["syn::token::Default"]},{"text":"impl Clone for Do","synthetic":false,"types":["syn::token::Do"]},{"text":"impl Clone for Dyn","synthetic":false,"types":["syn::token::Dyn"]},{"text":"impl Clone for Else","synthetic":false,"types":["syn::token::Else"]},{"text":"impl Clone for Enum","synthetic":false,"types":["syn::token::Enum"]},{"text":"impl Clone for Extern","synthetic":false,"types":["syn::token::Extern"]},{"text":"impl Clone for Final","synthetic":false,"types":["syn::token::Final"]},{"text":"impl Clone for Fn","synthetic":false,"types":["syn::token::Fn"]},{"text":"impl Clone for For","synthetic":false,"types":["syn::token::For"]},{"text":"impl Clone for If","synthetic":false,"types":["syn::token::If"]},{"text":"impl Clone for Impl","synthetic":false,"types":["syn::token::Impl"]},{"text":"impl Clone for In","synthetic":false,"types":["syn::token::In"]},{"text":"impl Clone for Let","synthetic":false,"types":["syn::token::Let"]},{"text":"impl Clone for Loop","synthetic":false,"types":["syn::token::Loop"]},{"text":"impl Clone for Macro","synthetic":false,"types":["syn::token::Macro"]},{"text":"impl Clone for Match","synthetic":false,"types":["syn::token::Match"]},{"text":"impl Clone for Mod","synthetic":false,"types":["syn::token::Mod"]},{"text":"impl Clone for Move","synthetic":false,"types":["syn::token::Move"]},{"text":"impl Clone for Mut","synthetic":false,"types":["syn::token::Mut"]},{"text":"impl Clone for Override","synthetic":false,"types":["syn::token::Override"]},{"text":"impl Clone for Priv","synthetic":false,"types":["syn::token::Priv"]},{"text":"impl Clone for Pub","synthetic":false,"types":["syn::token::Pub"]},{"text":"impl Clone for Ref","synthetic":false,"types":["syn::token::Ref"]},{"text":"impl Clone for Return","synthetic":false,"types":["syn::token::Return"]},{"text":"impl Clone for SelfType","synthetic":false,"types":["syn::token::SelfType"]},{"text":"impl Clone for SelfValue","synthetic":false,"types":["syn::token::SelfValue"]},{"text":"impl Clone for Static","synthetic":false,"types":["syn::token::Static"]},{"text":"impl Clone for Struct","synthetic":false,"types":["syn::token::Struct"]},{"text":"impl Clone for Super","synthetic":false,"types":["syn::token::Super"]},{"text":"impl Clone for Trait","synthetic":false,"types":["syn::token::Trait"]},{"text":"impl Clone for Try","synthetic":false,"types":["syn::token::Try"]},{"text":"impl Clone for Type","synthetic":false,"types":["syn::token::Type"]},{"text":"impl Clone for Typeof","synthetic":false,"types":["syn::token::Typeof"]},{"text":"impl Clone for Union","synthetic":false,"types":["syn::token::Union"]},{"text":"impl Clone for Unsafe","synthetic":false,"types":["syn::token::Unsafe"]},{"text":"impl Clone for Unsized","synthetic":false,"types":["syn::token::Unsized"]},{"text":"impl Clone for Use","synthetic":false,"types":["syn::token::Use"]},{"text":"impl Clone for Virtual","synthetic":false,"types":["syn::token::Virtual"]},{"text":"impl Clone for Where","synthetic":false,"types":["syn::token::Where"]},{"text":"impl Clone for While","synthetic":false,"types":["syn::token::While"]},{"text":"impl Clone for Yield","synthetic":false,"types":["syn::token::Yield"]},{"text":"impl Clone for Add","synthetic":false,"types":["syn::token::Add"]},{"text":"impl Clone for AddEq","synthetic":false,"types":["syn::token::AddEq"]},{"text":"impl Clone for And","synthetic":false,"types":["syn::token::And"]},{"text":"impl Clone for AndAnd","synthetic":false,"types":["syn::token::AndAnd"]},{"text":"impl Clone for AndEq","synthetic":false,"types":["syn::token::AndEq"]},{"text":"impl Clone for At","synthetic":false,"types":["syn::token::At"]},{"text":"impl Clone for Bang","synthetic":false,"types":["syn::token::Bang"]},{"text":"impl Clone for Caret","synthetic":false,"types":["syn::token::Caret"]},{"text":"impl Clone for CaretEq","synthetic":false,"types":["syn::token::CaretEq"]},{"text":"impl Clone for Colon","synthetic":false,"types":["syn::token::Colon"]},{"text":"impl Clone for Colon2","synthetic":false,"types":["syn::token::Colon2"]},{"text":"impl Clone for Comma","synthetic":false,"types":["syn::token::Comma"]},{"text":"impl Clone for Div","synthetic":false,"types":["syn::token::Div"]},{"text":"impl Clone for DivEq","synthetic":false,"types":["syn::token::DivEq"]},{"text":"impl Clone for Dollar","synthetic":false,"types":["syn::token::Dollar"]},{"text":"impl Clone for Dot","synthetic":false,"types":["syn::token::Dot"]},{"text":"impl Clone for Dot2","synthetic":false,"types":["syn::token::Dot2"]},{"text":"impl Clone for Dot3","synthetic":false,"types":["syn::token::Dot3"]},{"text":"impl Clone for DotDotEq","synthetic":false,"types":["syn::token::DotDotEq"]},{"text":"impl Clone for Eq","synthetic":false,"types":["syn::token::Eq"]},{"text":"impl Clone for EqEq","synthetic":false,"types":["syn::token::EqEq"]},{"text":"impl Clone for Ge","synthetic":false,"types":["syn::token::Ge"]},{"text":"impl Clone for Gt","synthetic":false,"types":["syn::token::Gt"]},{"text":"impl Clone for Le","synthetic":false,"types":["syn::token::Le"]},{"text":"impl Clone for Lt","synthetic":false,"types":["syn::token::Lt"]},{"text":"impl Clone for MulEq","synthetic":false,"types":["syn::token::MulEq"]},{"text":"impl Clone for Ne","synthetic":false,"types":["syn::token::Ne"]},{"text":"impl Clone for Or","synthetic":false,"types":["syn::token::Or"]},{"text":"impl Clone for OrEq","synthetic":false,"types":["syn::token::OrEq"]},{"text":"impl Clone for OrOr","synthetic":false,"types":["syn::token::OrOr"]},{"text":"impl Clone for Pound","synthetic":false,"types":["syn::token::Pound"]},{"text":"impl Clone for Question","synthetic":false,"types":["syn::token::Question"]},{"text":"impl Clone for RArrow","synthetic":false,"types":["syn::token::RArrow"]},{"text":"impl Clone for LArrow","synthetic":false,"types":["syn::token::LArrow"]},{"text":"impl Clone for Rem","synthetic":false,"types":["syn::token::Rem"]},{"text":"impl Clone for RemEq","synthetic":false,"types":["syn::token::RemEq"]},{"text":"impl Clone for FatArrow","synthetic":false,"types":["syn::token::FatArrow"]},{"text":"impl Clone for Semi","synthetic":false,"types":["syn::token::Semi"]},{"text":"impl Clone for Shl","synthetic":false,"types":["syn::token::Shl"]},{"text":"impl Clone for ShlEq","synthetic":false,"types":["syn::token::ShlEq"]},{"text":"impl Clone for Shr","synthetic":false,"types":["syn::token::Shr"]},{"text":"impl Clone for ShrEq","synthetic":false,"types":["syn::token::ShrEq"]},{"text":"impl Clone for Star","synthetic":false,"types":["syn::token::Star"]},{"text":"impl Clone for Sub","synthetic":false,"types":["syn::token::Sub"]},{"text":"impl Clone for SubEq","synthetic":false,"types":["syn::token::SubEq"]},{"text":"impl Clone for Tilde","synthetic":false,"types":["syn::token::Tilde"]},{"text":"impl Clone for Brace","synthetic":false,"types":["syn::token::Brace"]},{"text":"impl Clone for Bracket","synthetic":false,"types":["syn::token::Bracket"]},{"text":"impl Clone for Paren","synthetic":false,"types":["syn::token::Paren"]},{"text":"impl Clone for Group","synthetic":false,"types":["syn::token::Group"]},{"text":"impl<'a> Clone for ImplGenerics<'a>","synthetic":false,"types":["syn::generics::ImplGenerics"]},{"text":"impl<'a> Clone for TypeGenerics<'a>","synthetic":false,"types":["syn::generics::TypeGenerics"]},{"text":"impl<'a> Clone for Turbofish<'a>","synthetic":false,"types":["syn::generics::Turbofish"]},{"text":"impl Clone for Lifetime","synthetic":false,"types":["syn::lifetime::Lifetime"]},{"text":"impl Clone for LitStr","synthetic":false,"types":["syn::lit::LitStr"]},{"text":"impl Clone for LitByteStr","synthetic":false,"types":["syn::lit::LitByteStr"]},{"text":"impl Clone for LitByte","synthetic":false,"types":["syn::lit::LitByte"]},{"text":"impl Clone for LitChar","synthetic":false,"types":["syn::lit::LitChar"]},{"text":"impl Clone for LitInt","synthetic":false,"types":["syn::lit::LitInt"]},{"text":"impl Clone for LitFloat","synthetic":false,"types":["syn::lit::LitFloat"]},{"text":"impl<'a> Clone for Cursor<'a>","synthetic":false,"types":["syn::buffer::Cursor"]},{"text":"impl<T, P> Clone for Punctuated<T, P> where
    T: Clone,
    P: Clone, ","synthetic":false,"types":["syn::punctuated::Punctuated"]},{"text":"impl<'a, T, P> Clone for Pairs<'a, T, P>","synthetic":false,"types":["syn::punctuated::Pairs"]},{"text":"impl<T, P> Clone for IntoPairs<T, P> where
    T: Clone,
    P: Clone, ","synthetic":false,"types":["syn::punctuated::IntoPairs"]},{"text":"impl<T> Clone for IntoIter<T> where
    T: Clone, ","synthetic":false,"types":["syn::punctuated::IntoIter"]},{"text":"impl<'a, T> Clone for Iter<'a, T>","synthetic":false,"types":["syn::punctuated::Iter"]},{"text":"impl<T, P> Clone for Pair<T, P> where
    T: Clone,
    P: Clone, ","synthetic":false,"types":["syn::punctuated::Pair"]},{"text":"impl Clone for Abi","synthetic":false,"types":["syn::ty::Abi"]},{"text":"impl Clone for AngleBracketedGenericArguments","synthetic":false,"types":["syn::path::AngleBracketedGenericArguments"]},{"text":"impl Clone for AttrStyle","synthetic":false,"types":["syn::attr::AttrStyle"]},{"text":"impl Clone for Attribute","synthetic":false,"types":["syn::attr::Attribute"]},{"text":"impl Clone for BareFnArg","synthetic":false,"types":["syn::ty::BareFnArg"]},{"text":"impl Clone for BinOp","synthetic":false,"types":["syn::op::BinOp"]},{"text":"impl Clone for Binding","synthetic":false,"types":["syn::path::Binding"]},{"text":"impl Clone for BoundLifetimes","synthetic":false,"types":["syn::generics::BoundLifetimes"]},{"text":"impl Clone for ConstParam","synthetic":false,"types":["syn::generics::ConstParam"]},{"text":"impl Clone for Constraint","synthetic":false,"types":["syn::path::Constraint"]},{"text":"impl Clone for Data","synthetic":false,"types":["syn::derive::Data"]},{"text":"impl Clone for DataEnum","synthetic":false,"types":["syn::derive::DataEnum"]},{"text":"impl Clone for DataStruct","synthetic":false,"types":["syn::derive::DataStruct"]},{"text":"impl Clone for DataUnion","synthetic":false,"types":["syn::derive::DataUnion"]},{"text":"impl Clone for DeriveInput","synthetic":false,"types":["syn::derive::DeriveInput"]},{"text":"impl Clone for Expr","synthetic":false,"types":["syn::expr::Expr"]},{"text":"impl Clone for ExprBinary","synthetic":false,"types":["syn::expr::ExprBinary"]},{"text":"impl Clone for ExprCall","synthetic":false,"types":["syn::expr::ExprCall"]},{"text":"impl Clone for ExprCast","synthetic":false,"types":["syn::expr::ExprCast"]},{"text":"impl Clone for ExprField","synthetic":false,"types":["syn::expr::ExprField"]},{"text":"impl Clone for ExprIndex","synthetic":false,"types":["syn::expr::ExprIndex"]},{"text":"impl Clone for ExprLit","synthetic":false,"types":["syn::expr::ExprLit"]},{"text":"impl Clone for ExprParen","synthetic":false,"types":["syn::expr::ExprParen"]},{"text":"impl Clone for ExprPath","synthetic":false,"types":["syn::expr::ExprPath"]},{"text":"impl Clone for ExprUnary","synthetic":false,"types":["syn::expr::ExprUnary"]},{"text":"impl Clone for Field","synthetic":false,"types":["syn::data::Field"]},{"text":"impl Clone for Fields","synthetic":false,"types":["syn::data::Fields"]},{"text":"impl Clone for FieldsNamed","synthetic":false,"types":["syn::data::FieldsNamed"]},{"text":"impl Clone for FieldsUnnamed","synthetic":false,"types":["syn::data::FieldsUnnamed"]},{"text":"impl Clone for GenericArgument","synthetic":false,"types":["syn::path::GenericArgument"]},{"text":"impl Clone for GenericParam","synthetic":false,"types":["syn::generics::GenericParam"]},{"text":"impl Clone for Generics","synthetic":false,"types":["syn::generics::Generics"]},{"text":"impl Clone for Index","synthetic":false,"types":["syn::expr::Index"]},{"text":"impl Clone for LifetimeDef","synthetic":false,"types":["syn::generics::LifetimeDef"]},{"text":"impl Clone for Lit","synthetic":false,"types":["syn::lit::Lit"]},{"text":"impl Clone for LitBool","synthetic":false,"types":["syn::lit::LitBool"]},{"text":"impl Clone for Macro","synthetic":false,"types":["syn::mac::Macro"]},{"text":"impl Clone for MacroDelimiter","synthetic":false,"types":["syn::mac::MacroDelimiter"]},{"text":"impl Clone for Member","synthetic":false,"types":["syn::expr::Member"]},{"text":"impl Clone for Meta","synthetic":false,"types":["syn::attr::Meta"]},{"text":"impl Clone for MetaList","synthetic":false,"types":["syn::attr::MetaList"]},{"text":"impl Clone for MetaNameValue","synthetic":false,"types":["syn::attr::MetaNameValue"]},{"text":"impl Clone for NestedMeta","synthetic":false,"types":["syn::attr::NestedMeta"]},{"text":"impl Clone for ParenthesizedGenericArguments","synthetic":false,"types":["syn::path::ParenthesizedGenericArguments"]},{"text":"impl Clone for Path","synthetic":false,"types":["syn::path::Path"]},{"text":"impl Clone for PathArguments","synthetic":false,"types":["syn::path::PathArguments"]},{"text":"impl Clone for PathSegment","synthetic":false,"types":["syn::path::PathSegment"]},{"text":"impl Clone for PredicateEq","synthetic":false,"types":["syn::generics::PredicateEq"]},{"text":"impl Clone for PredicateLifetime","synthetic":false,"types":["syn::generics::PredicateLifetime"]},{"text":"impl Clone for PredicateType","synthetic":false,"types":["syn::generics::PredicateType"]},{"text":"impl Clone for QSelf","synthetic":false,"types":["syn::path::QSelf"]},{"text":"impl Clone for ReturnType","synthetic":false,"types":["syn::ty::ReturnType"]},{"text":"impl Clone for TraitBound","synthetic":false,"types":["syn::generics::TraitBound"]},{"text":"impl Clone for TraitBoundModifier","synthetic":false,"types":["syn::generics::TraitBoundModifier"]},{"text":"impl Clone for Type","synthetic":false,"types":["syn::ty::Type"]},{"text":"impl Clone for TypeArray","synthetic":false,"types":["syn::ty::TypeArray"]},{"text":"impl Clone for TypeBareFn","synthetic":false,"types":["syn::ty::TypeBareFn"]},{"text":"impl Clone for TypeGroup","synthetic":false,"types":["syn::ty::TypeGroup"]},{"text":"impl Clone for TypeImplTrait","synthetic":false,"types":["syn::ty::TypeImplTrait"]},{"text":"impl Clone for TypeInfer","synthetic":false,"types":["syn::ty::TypeInfer"]},{"text":"impl Clone for TypeMacro","synthetic":false,"types":["syn::ty::TypeMacro"]},{"text":"impl Clone for TypeNever","synthetic":false,"types":["syn::ty::TypeNever"]},{"text":"impl Clone for TypeParam","synthetic":false,"types":["syn::generics::TypeParam"]},{"text":"impl Clone for TypeParamBound","synthetic":false,"types":["syn::generics::TypeParamBound"]},{"text":"impl Clone for TypeParen","synthetic":false,"types":["syn::ty::TypeParen"]},{"text":"impl Clone for TypePath","synthetic":false,"types":["syn::ty::TypePath"]},{"text":"impl Clone for TypePtr","synthetic":false,"types":["syn::ty::TypePtr"]},{"text":"impl Clone for TypeReference","synthetic":false,"types":["syn::ty::TypeReference"]},{"text":"impl Clone for TypeSlice","synthetic":false,"types":["syn::ty::TypeSlice"]},{"text":"impl Clone for TypeTraitObject","synthetic":false,"types":["syn::ty::TypeTraitObject"]},{"text":"impl Clone for TypeTuple","synthetic":false,"types":["syn::ty::TypeTuple"]},{"text":"impl Clone for UnOp","synthetic":false,"types":["syn::op::UnOp"]},{"text":"impl Clone for Variadic","synthetic":false,"types":["syn::ty::Variadic"]},{"text":"impl Clone for Variant","synthetic":false,"types":["syn::data::Variant"]},{"text":"impl Clone for VisCrate","synthetic":false,"types":["syn::data::VisCrate"]},{"text":"impl Clone for VisPublic","synthetic":false,"types":["syn::data::VisPublic"]},{"text":"impl Clone for VisRestricted","synthetic":false,"types":["syn::data::VisRestricted"]},{"text":"impl Clone for Visibility","synthetic":false,"types":["syn::data::Visibility"]},{"text":"impl Clone for WhereClause","synthetic":false,"types":["syn::generics::WhereClause"]},{"text":"impl Clone for WherePredicate","synthetic":false,"types":["syn::generics::WherePredicate"]},{"text":"impl<'c, 'a> Clone for StepCursor<'c, 'a>","synthetic":false,"types":["syn::parse::StepCursor"]},{"text":"impl Clone for Error","synthetic":false,"types":["syn::error::Error"]}]; +implementors["synstructure"] = [{"text":"impl Clone for AddBounds","synthetic":false,"types":["synstructure::AddBounds"]},{"text":"impl Clone for BindStyle","synthetic":false,"types":["synstructure::BindStyle"]},{"text":"impl<'a> Clone for BindingInfo<'a>","synthetic":false,"types":["synstructure::BindingInfo"]},{"text":"impl<'a> Clone for VariantAst<'a>","synthetic":false,"types":["synstructure::VariantAst"]},{"text":"impl<'a> Clone for VariantInfo<'a>","synthetic":false,"types":["synstructure::VariantInfo"]},{"text":"impl<'a> Clone for Structure<'a>","synthetic":false,"types":["synstructure::Structure"]}]; if (window.register_implementors) {window.register_implementors(implementors);} else {window.pending_implementors = implementors;}})() \ No newline at end of file diff --git a/implementors/core/cmp/trait.Eq.js b/implementors/core/cmp/trait.Eq.js index 115cab1..e177ced 100644 --- a/implementors/core/cmp/trait.Eq.js +++ b/implementors/core/cmp/trait.Eq.js @@ -1,7 +1,7 @@ (function() {var implementors = {}; -implementors["flexiber"] = [{"text":"impl Eq for Error","synthetic":false,"types":[]},{"text":"impl Eq for ErrorKind","synthetic":false,"types":[]},{"text":"impl Eq for Length","synthetic":false,"types":[]},{"text":"impl Eq for SimpleTag","synthetic":false,"types":[]},{"text":"impl<'a> Eq for Slice<'a>","synthetic":false,"types":[]},{"text":"impl Eq for Class","synthetic":false,"types":[]},{"text":"impl Eq for Tag","synthetic":false,"types":[]},{"text":"impl<V: Eq, T: Eq> Eq for TaggedValue<V, T>","synthetic":false,"types":[]}]; -implementors["log"] = [{"text":"impl Eq for Level","synthetic":false,"types":[]},{"text":"impl Eq for LevelFilter","synthetic":false,"types":[]},{"text":"impl<'a> Eq for Metadata<'a>","synthetic":false,"types":[]},{"text":"impl<'a> Eq for MetadataBuilder<'a>","synthetic":false,"types":[]}]; -implementors["proc_macro2"] = [{"text":"impl Eq for Delimiter","synthetic":false,"types":[]},{"text":"impl Eq for Spacing","synthetic":false,"types":[]},{"text":"impl Eq for Ident","synthetic":false,"types":[]}]; -implementors["syn"] = [{"text":"impl Eq for Underscore","synthetic":false,"types":[]},{"text":"impl Eq for Abstract","synthetic":false,"types":[]},{"text":"impl Eq for As","synthetic":false,"types":[]},{"text":"impl Eq for Async","synthetic":false,"types":[]},{"text":"impl Eq for Auto","synthetic":false,"types":[]},{"text":"impl Eq for Await","synthetic":false,"types":[]},{"text":"impl Eq for Become","synthetic":false,"types":[]},{"text":"impl Eq for Box","synthetic":false,"types":[]},{"text":"impl Eq for Break","synthetic":false,"types":[]},{"text":"impl Eq for Const","synthetic":false,"types":[]},{"text":"impl Eq for Continue","synthetic":false,"types":[]},{"text":"impl Eq for Crate","synthetic":false,"types":[]},{"text":"impl Eq for Default","synthetic":false,"types":[]},{"text":"impl Eq for Do","synthetic":false,"types":[]},{"text":"impl Eq for Dyn","synthetic":false,"types":[]},{"text":"impl Eq for Else","synthetic":false,"types":[]},{"text":"impl Eq for Enum","synthetic":false,"types":[]},{"text":"impl Eq for Extern","synthetic":false,"types":[]},{"text":"impl Eq for Final","synthetic":false,"types":[]},{"text":"impl Eq for Fn","synthetic":false,"types":[]},{"text":"impl Eq for For","synthetic":false,"types":[]},{"text":"impl Eq for If","synthetic":false,"types":[]},{"text":"impl Eq for Impl","synthetic":false,"types":[]},{"text":"impl Eq for In","synthetic":false,"types":[]},{"text":"impl Eq for Let","synthetic":false,"types":[]},{"text":"impl Eq for Loop","synthetic":false,"types":[]},{"text":"impl Eq for Macro","synthetic":false,"types":[]},{"text":"impl Eq for Match","synthetic":false,"types":[]},{"text":"impl Eq for Mod","synthetic":false,"types":[]},{"text":"impl Eq for Move","synthetic":false,"types":[]},{"text":"impl Eq for Mut","synthetic":false,"types":[]},{"text":"impl Eq for Override","synthetic":false,"types":[]},{"text":"impl Eq for Priv","synthetic":false,"types":[]},{"text":"impl Eq for Pub","synthetic":false,"types":[]},{"text":"impl Eq for Ref","synthetic":false,"types":[]},{"text":"impl Eq for Return","synthetic":false,"types":[]},{"text":"impl Eq for SelfType","synthetic":false,"types":[]},{"text":"impl Eq for SelfValue","synthetic":false,"types":[]},{"text":"impl Eq for Static","synthetic":false,"types":[]},{"text":"impl Eq for Struct","synthetic":false,"types":[]},{"text":"impl Eq for Super","synthetic":false,"types":[]},{"text":"impl Eq for Trait","synthetic":false,"types":[]},{"text":"impl Eq for Try","synthetic":false,"types":[]},{"text":"impl Eq for Type","synthetic":false,"types":[]},{"text":"impl Eq for Typeof","synthetic":false,"types":[]},{"text":"impl Eq for Union","synthetic":false,"types":[]},{"text":"impl Eq for Unsafe","synthetic":false,"types":[]},{"text":"impl Eq for Unsized","synthetic":false,"types":[]},{"text":"impl Eq for Use","synthetic":false,"types":[]},{"text":"impl Eq for Virtual","synthetic":false,"types":[]},{"text":"impl Eq for Where","synthetic":false,"types":[]},{"text":"impl Eq for While","synthetic":false,"types":[]},{"text":"impl Eq for Yield","synthetic":false,"types":[]},{"text":"impl Eq for Add","synthetic":false,"types":[]},{"text":"impl Eq for AddEq","synthetic":false,"types":[]},{"text":"impl Eq for And","synthetic":false,"types":[]},{"text":"impl Eq for AndAnd","synthetic":false,"types":[]},{"text":"impl Eq for AndEq","synthetic":false,"types":[]},{"text":"impl Eq for At","synthetic":false,"types":[]},{"text":"impl Eq for Bang","synthetic":false,"types":[]},{"text":"impl Eq for Caret","synthetic":false,"types":[]},{"text":"impl Eq for CaretEq","synthetic":false,"types":[]},{"text":"impl Eq for Colon","synthetic":false,"types":[]},{"text":"impl Eq for Colon2","synthetic":false,"types":[]},{"text":"impl Eq for Comma","synthetic":false,"types":[]},{"text":"impl Eq for Div","synthetic":false,"types":[]},{"text":"impl Eq for DivEq","synthetic":false,"types":[]},{"text":"impl Eq for Dollar","synthetic":false,"types":[]},{"text":"impl Eq for Dot","synthetic":false,"types":[]},{"text":"impl Eq for Dot2","synthetic":false,"types":[]},{"text":"impl Eq for Dot3","synthetic":false,"types":[]},{"text":"impl Eq for DotDotEq","synthetic":false,"types":[]},{"text":"impl Eq for Eq","synthetic":false,"types":[]},{"text":"impl Eq for EqEq","synthetic":false,"types":[]},{"text":"impl Eq for Ge","synthetic":false,"types":[]},{"text":"impl Eq for Gt","synthetic":false,"types":[]},{"text":"impl Eq for Le","synthetic":false,"types":[]},{"text":"impl Eq for Lt","synthetic":false,"types":[]},{"text":"impl Eq for MulEq","synthetic":false,"types":[]},{"text":"impl Eq for Ne","synthetic":false,"types":[]},{"text":"impl Eq for Or","synthetic":false,"types":[]},{"text":"impl Eq for OrEq","synthetic":false,"types":[]},{"text":"impl Eq for OrOr","synthetic":false,"types":[]},{"text":"impl Eq for Pound","synthetic":false,"types":[]},{"text":"impl Eq for Question","synthetic":false,"types":[]},{"text":"impl Eq for RArrow","synthetic":false,"types":[]},{"text":"impl Eq for LArrow","synthetic":false,"types":[]},{"text":"impl Eq for Rem","synthetic":false,"types":[]},{"text":"impl Eq for RemEq","synthetic":false,"types":[]},{"text":"impl Eq for FatArrow","synthetic":false,"types":[]},{"text":"impl Eq for Semi","synthetic":false,"types":[]},{"text":"impl Eq for Shl","synthetic":false,"types":[]},{"text":"impl Eq for ShlEq","synthetic":false,"types":[]},{"text":"impl Eq for Shr","synthetic":false,"types":[]},{"text":"impl Eq for ShrEq","synthetic":false,"types":[]},{"text":"impl Eq for Star","synthetic":false,"types":[]},{"text":"impl Eq for Sub","synthetic":false,"types":[]},{"text":"impl Eq for SubEq","synthetic":false,"types":[]},{"text":"impl Eq for Tilde","synthetic":false,"types":[]},{"text":"impl Eq for Brace","synthetic":false,"types":[]},{"text":"impl Eq for Bracket","synthetic":false,"types":[]},{"text":"impl Eq for Paren","synthetic":false,"types":[]},{"text":"impl Eq for Group","synthetic":false,"types":[]},{"text":"impl Eq for Member","synthetic":false,"types":[]},{"text":"impl Eq for Index","synthetic":false,"types":[]},{"text":"impl<'a> Eq for ImplGenerics<'a>","synthetic":false,"types":[]},{"text":"impl<'a> Eq for TypeGenerics<'a>","synthetic":false,"types":[]},{"text":"impl<'a> Eq for Turbofish<'a>","synthetic":false,"types":[]},{"text":"impl Eq for Lifetime","synthetic":false,"types":[]},{"text":"impl<'a> Eq for Cursor<'a>","synthetic":false,"types":[]},{"text":"impl<T, P> Eq for Punctuated<T, P> where
    T: Eq,
    P: Eq, ","synthetic":false,"types":[]},{"text":"impl Eq for Abi","synthetic":false,"types":[]},{"text":"impl Eq for AngleBracketedGenericArguments","synthetic":false,"types":[]},{"text":"impl Eq for AttrStyle","synthetic":false,"types":[]},{"text":"impl Eq for Attribute","synthetic":false,"types":[]},{"text":"impl Eq for BareFnArg","synthetic":false,"types":[]},{"text":"impl Eq for BinOp","synthetic":false,"types":[]},{"text":"impl Eq for Binding","synthetic":false,"types":[]},{"text":"impl Eq for BoundLifetimes","synthetic":false,"types":[]},{"text":"impl Eq for ConstParam","synthetic":false,"types":[]},{"text":"impl Eq for Constraint","synthetic":false,"types":[]},{"text":"impl Eq for Data","synthetic":false,"types":[]},{"text":"impl Eq for DataEnum","synthetic":false,"types":[]},{"text":"impl Eq for DataStruct","synthetic":false,"types":[]},{"text":"impl Eq for DataUnion","synthetic":false,"types":[]},{"text":"impl Eq for DeriveInput","synthetic":false,"types":[]},{"text":"impl Eq for Expr","synthetic":false,"types":[]},{"text":"impl Eq for ExprBinary","synthetic":false,"types":[]},{"text":"impl Eq for ExprCall","synthetic":false,"types":[]},{"text":"impl Eq for ExprCast","synthetic":false,"types":[]},{"text":"impl Eq for ExprField","synthetic":false,"types":[]},{"text":"impl Eq for ExprIndex","synthetic":false,"types":[]},{"text":"impl Eq for ExprLit","synthetic":false,"types":[]},{"text":"impl Eq for ExprParen","synthetic":false,"types":[]},{"text":"impl Eq for ExprPath","synthetic":false,"types":[]},{"text":"impl Eq for ExprUnary","synthetic":false,"types":[]},{"text":"impl Eq for Field","synthetic":false,"types":[]},{"text":"impl Eq for Fields","synthetic":false,"types":[]},{"text":"impl Eq for FieldsNamed","synthetic":false,"types":[]},{"text":"impl Eq for FieldsUnnamed","synthetic":false,"types":[]},{"text":"impl Eq for GenericArgument","synthetic":false,"types":[]},{"text":"impl Eq for GenericParam","synthetic":false,"types":[]},{"text":"impl Eq for Generics","synthetic":false,"types":[]},{"text":"impl Eq for LifetimeDef","synthetic":false,"types":[]},{"text":"impl Eq for Lit","synthetic":false,"types":[]},{"text":"impl Eq for LitBool","synthetic":false,"types":[]},{"text":"impl Eq for LitByte","synthetic":false,"types":[]},{"text":"impl Eq for LitByteStr","synthetic":false,"types":[]},{"text":"impl Eq for LitChar","synthetic":false,"types":[]},{"text":"impl Eq for LitFloat","synthetic":false,"types":[]},{"text":"impl Eq for LitInt","synthetic":false,"types":[]},{"text":"impl Eq for LitStr","synthetic":false,"types":[]},{"text":"impl Eq for Macro","synthetic":false,"types":[]},{"text":"impl Eq for MacroDelimiter","synthetic":false,"types":[]},{"text":"impl Eq for Meta","synthetic":false,"types":[]},{"text":"impl Eq for MetaList","synthetic":false,"types":[]},{"text":"impl Eq for MetaNameValue","synthetic":false,"types":[]},{"text":"impl Eq for NestedMeta","synthetic":false,"types":[]},{"text":"impl Eq for ParenthesizedGenericArguments","synthetic":false,"types":[]},{"text":"impl Eq for Path","synthetic":false,"types":[]},{"text":"impl Eq for PathArguments","synthetic":false,"types":[]},{"text":"impl Eq for PathSegment","synthetic":false,"types":[]},{"text":"impl Eq for PredicateEq","synthetic":false,"types":[]},{"text":"impl Eq for PredicateLifetime","synthetic":false,"types":[]},{"text":"impl Eq for PredicateType","synthetic":false,"types":[]},{"text":"impl Eq for QSelf","synthetic":false,"types":[]},{"text":"impl Eq for ReturnType","synthetic":false,"types":[]},{"text":"impl Eq for TraitBound","synthetic":false,"types":[]},{"text":"impl Eq for TraitBoundModifier","synthetic":false,"types":[]},{"text":"impl Eq for Type","synthetic":false,"types":[]},{"text":"impl Eq for TypeArray","synthetic":false,"types":[]},{"text":"impl Eq for TypeBareFn","synthetic":false,"types":[]},{"text":"impl Eq for TypeGroup","synthetic":false,"types":[]},{"text":"impl Eq for TypeImplTrait","synthetic":false,"types":[]},{"text":"impl Eq for TypeInfer","synthetic":false,"types":[]},{"text":"impl Eq for TypeMacro","synthetic":false,"types":[]},{"text":"impl Eq for TypeNever","synthetic":false,"types":[]},{"text":"impl Eq for TypeParam","synthetic":false,"types":[]},{"text":"impl Eq for TypeParamBound","synthetic":false,"types":[]},{"text":"impl Eq for TypeParen","synthetic":false,"types":[]},{"text":"impl Eq for TypePath","synthetic":false,"types":[]},{"text":"impl Eq for TypePtr","synthetic":false,"types":[]},{"text":"impl Eq for TypeReference","synthetic":false,"types":[]},{"text":"impl Eq for TypeSlice","synthetic":false,"types":[]},{"text":"impl Eq for TypeTraitObject","synthetic":false,"types":[]},{"text":"impl Eq for TypeTuple","synthetic":false,"types":[]},{"text":"impl Eq for UnOp","synthetic":false,"types":[]},{"text":"impl Eq for Variadic","synthetic":false,"types":[]},{"text":"impl Eq for Variant","synthetic":false,"types":[]},{"text":"impl Eq for VisCrate","synthetic":false,"types":[]},{"text":"impl Eq for VisPublic","synthetic":false,"types":[]},{"text":"impl Eq for VisRestricted","synthetic":false,"types":[]},{"text":"impl Eq for Visibility","synthetic":false,"types":[]},{"text":"impl Eq for WhereClause","synthetic":false,"types":[]},{"text":"impl Eq for WherePredicate","synthetic":false,"types":[]}]; -implementors["synstructure"] = [{"text":"impl Eq for AddBounds","synthetic":false,"types":[]},{"text":"impl Eq for BindStyle","synthetic":false,"types":[]},{"text":"impl<'a> Eq for BindingInfo<'a>","synthetic":false,"types":[]},{"text":"impl<'a> Eq for VariantAst<'a>","synthetic":false,"types":[]},{"text":"impl<'a> Eq for VariantInfo<'a>","synthetic":false,"types":[]},{"text":"impl<'a> Eq for Structure<'a>","synthetic":false,"types":[]}]; +implementors["flexiber"] = [{"text":"impl Eq for Error","synthetic":false,"types":["flexiber::error::Error"]},{"text":"impl Eq for ErrorKind","synthetic":false,"types":["flexiber::error::ErrorKind"]},{"text":"impl Eq for Length","synthetic":false,"types":["flexiber::length::Length"]},{"text":"impl Eq for SimpleTag","synthetic":false,"types":["flexiber::simpletag::SimpleTag"]},{"text":"impl<'a> Eq for Slice<'a>","synthetic":false,"types":["flexiber::slice::Slice"]},{"text":"impl Eq for Class","synthetic":false,"types":["flexiber::tag::Class"]},{"text":"impl Eq for Tag","synthetic":false,"types":["flexiber::tag::Tag"]},{"text":"impl<V: Eq, T: Eq> Eq for TaggedValue<V, T>","synthetic":false,"types":["flexiber::tagged::TaggedValue"]}]; +implementors["log"] = [{"text":"impl Eq for Level","synthetic":false,"types":["log::Level"]},{"text":"impl Eq for LevelFilter","synthetic":false,"types":["log::LevelFilter"]},{"text":"impl<'a> Eq for Metadata<'a>","synthetic":false,"types":["log::Metadata"]},{"text":"impl<'a> Eq for MetadataBuilder<'a>","synthetic":false,"types":["log::MetadataBuilder"]}]; +implementors["proc_macro2"] = [{"text":"impl Eq for Delimiter","synthetic":false,"types":["proc_macro2::Delimiter"]},{"text":"impl Eq for Spacing","synthetic":false,"types":["proc_macro2::Spacing"]},{"text":"impl Eq for Ident","synthetic":false,"types":["proc_macro2::Ident"]}]; +implementors["syn"] = [{"text":"impl Eq for Underscore","synthetic":false,"types":["syn::token::Underscore"]},{"text":"impl Eq for Abstract","synthetic":false,"types":["syn::token::Abstract"]},{"text":"impl Eq for As","synthetic":false,"types":["syn::token::As"]},{"text":"impl Eq for Async","synthetic":false,"types":["syn::token::Async"]},{"text":"impl Eq for Auto","synthetic":false,"types":["syn::token::Auto"]},{"text":"impl Eq for Await","synthetic":false,"types":["syn::token::Await"]},{"text":"impl Eq for Become","synthetic":false,"types":["syn::token::Become"]},{"text":"impl Eq for Box","synthetic":false,"types":["syn::token::Box"]},{"text":"impl Eq for Break","synthetic":false,"types":["syn::token::Break"]},{"text":"impl Eq for Const","synthetic":false,"types":["syn::token::Const"]},{"text":"impl Eq for Continue","synthetic":false,"types":["syn::token::Continue"]},{"text":"impl Eq for Crate","synthetic":false,"types":["syn::token::Crate"]},{"text":"impl Eq for Default","synthetic":false,"types":["syn::token::Default"]},{"text":"impl Eq for Do","synthetic":false,"types":["syn::token::Do"]},{"text":"impl Eq for Dyn","synthetic":false,"types":["syn::token::Dyn"]},{"text":"impl Eq for Else","synthetic":false,"types":["syn::token::Else"]},{"text":"impl Eq for Enum","synthetic":false,"types":["syn::token::Enum"]},{"text":"impl Eq for Extern","synthetic":false,"types":["syn::token::Extern"]},{"text":"impl Eq for Final","synthetic":false,"types":["syn::token::Final"]},{"text":"impl Eq for Fn","synthetic":false,"types":["syn::token::Fn"]},{"text":"impl Eq for For","synthetic":false,"types":["syn::token::For"]},{"text":"impl Eq for If","synthetic":false,"types":["syn::token::If"]},{"text":"impl Eq for Impl","synthetic":false,"types":["syn::token::Impl"]},{"text":"impl Eq for In","synthetic":false,"types":["syn::token::In"]},{"text":"impl Eq for Let","synthetic":false,"types":["syn::token::Let"]},{"text":"impl Eq for Loop","synthetic":false,"types":["syn::token::Loop"]},{"text":"impl Eq for Macro","synthetic":false,"types":["syn::token::Macro"]},{"text":"impl Eq for Match","synthetic":false,"types":["syn::token::Match"]},{"text":"impl Eq for Mod","synthetic":false,"types":["syn::token::Mod"]},{"text":"impl Eq for Move","synthetic":false,"types":["syn::token::Move"]},{"text":"impl Eq for Mut","synthetic":false,"types":["syn::token::Mut"]},{"text":"impl Eq for Override","synthetic":false,"types":["syn::token::Override"]},{"text":"impl Eq for Priv","synthetic":false,"types":["syn::token::Priv"]},{"text":"impl Eq for Pub","synthetic":false,"types":["syn::token::Pub"]},{"text":"impl Eq for Ref","synthetic":false,"types":["syn::token::Ref"]},{"text":"impl Eq for Return","synthetic":false,"types":["syn::token::Return"]},{"text":"impl Eq for SelfType","synthetic":false,"types":["syn::token::SelfType"]},{"text":"impl Eq for SelfValue","synthetic":false,"types":["syn::token::SelfValue"]},{"text":"impl Eq for Static","synthetic":false,"types":["syn::token::Static"]},{"text":"impl Eq for Struct","synthetic":false,"types":["syn::token::Struct"]},{"text":"impl Eq for Super","synthetic":false,"types":["syn::token::Super"]},{"text":"impl Eq for Trait","synthetic":false,"types":["syn::token::Trait"]},{"text":"impl Eq for Try","synthetic":false,"types":["syn::token::Try"]},{"text":"impl Eq for Type","synthetic":false,"types":["syn::token::Type"]},{"text":"impl Eq for Typeof","synthetic":false,"types":["syn::token::Typeof"]},{"text":"impl Eq for Union","synthetic":false,"types":["syn::token::Union"]},{"text":"impl Eq for Unsafe","synthetic":false,"types":["syn::token::Unsafe"]},{"text":"impl Eq for Unsized","synthetic":false,"types":["syn::token::Unsized"]},{"text":"impl Eq for Use","synthetic":false,"types":["syn::token::Use"]},{"text":"impl Eq for Virtual","synthetic":false,"types":["syn::token::Virtual"]},{"text":"impl Eq for Where","synthetic":false,"types":["syn::token::Where"]},{"text":"impl Eq for While","synthetic":false,"types":["syn::token::While"]},{"text":"impl Eq for Yield","synthetic":false,"types":["syn::token::Yield"]},{"text":"impl Eq for Add","synthetic":false,"types":["syn::token::Add"]},{"text":"impl Eq for AddEq","synthetic":false,"types":["syn::token::AddEq"]},{"text":"impl Eq for And","synthetic":false,"types":["syn::token::And"]},{"text":"impl Eq for AndAnd","synthetic":false,"types":["syn::token::AndAnd"]},{"text":"impl Eq for AndEq","synthetic":false,"types":["syn::token::AndEq"]},{"text":"impl Eq for At","synthetic":false,"types":["syn::token::At"]},{"text":"impl Eq for Bang","synthetic":false,"types":["syn::token::Bang"]},{"text":"impl Eq for Caret","synthetic":false,"types":["syn::token::Caret"]},{"text":"impl Eq for CaretEq","synthetic":false,"types":["syn::token::CaretEq"]},{"text":"impl Eq for Colon","synthetic":false,"types":["syn::token::Colon"]},{"text":"impl Eq for Colon2","synthetic":false,"types":["syn::token::Colon2"]},{"text":"impl Eq for Comma","synthetic":false,"types":["syn::token::Comma"]},{"text":"impl Eq for Div","synthetic":false,"types":["syn::token::Div"]},{"text":"impl Eq for DivEq","synthetic":false,"types":["syn::token::DivEq"]},{"text":"impl Eq for Dollar","synthetic":false,"types":["syn::token::Dollar"]},{"text":"impl Eq for Dot","synthetic":false,"types":["syn::token::Dot"]},{"text":"impl Eq for Dot2","synthetic":false,"types":["syn::token::Dot2"]},{"text":"impl Eq for Dot3","synthetic":false,"types":["syn::token::Dot3"]},{"text":"impl Eq for DotDotEq","synthetic":false,"types":["syn::token::DotDotEq"]},{"text":"impl Eq for Eq","synthetic":false,"types":["syn::token::Eq"]},{"text":"impl Eq for EqEq","synthetic":false,"types":["syn::token::EqEq"]},{"text":"impl Eq for Ge","synthetic":false,"types":["syn::token::Ge"]},{"text":"impl Eq for Gt","synthetic":false,"types":["syn::token::Gt"]},{"text":"impl Eq for Le","synthetic":false,"types":["syn::token::Le"]},{"text":"impl Eq for Lt","synthetic":false,"types":["syn::token::Lt"]},{"text":"impl Eq for MulEq","synthetic":false,"types":["syn::token::MulEq"]},{"text":"impl Eq for Ne","synthetic":false,"types":["syn::token::Ne"]},{"text":"impl Eq for Or","synthetic":false,"types":["syn::token::Or"]},{"text":"impl Eq for OrEq","synthetic":false,"types":["syn::token::OrEq"]},{"text":"impl Eq for OrOr","synthetic":false,"types":["syn::token::OrOr"]},{"text":"impl Eq for Pound","synthetic":false,"types":["syn::token::Pound"]},{"text":"impl Eq for Question","synthetic":false,"types":["syn::token::Question"]},{"text":"impl Eq for RArrow","synthetic":false,"types":["syn::token::RArrow"]},{"text":"impl Eq for LArrow","synthetic":false,"types":["syn::token::LArrow"]},{"text":"impl Eq for Rem","synthetic":false,"types":["syn::token::Rem"]},{"text":"impl Eq for RemEq","synthetic":false,"types":["syn::token::RemEq"]},{"text":"impl Eq for FatArrow","synthetic":false,"types":["syn::token::FatArrow"]},{"text":"impl Eq for Semi","synthetic":false,"types":["syn::token::Semi"]},{"text":"impl Eq for Shl","synthetic":false,"types":["syn::token::Shl"]},{"text":"impl Eq for ShlEq","synthetic":false,"types":["syn::token::ShlEq"]},{"text":"impl Eq for Shr","synthetic":false,"types":["syn::token::Shr"]},{"text":"impl Eq for ShrEq","synthetic":false,"types":["syn::token::ShrEq"]},{"text":"impl Eq for Star","synthetic":false,"types":["syn::token::Star"]},{"text":"impl Eq for Sub","synthetic":false,"types":["syn::token::Sub"]},{"text":"impl Eq for SubEq","synthetic":false,"types":["syn::token::SubEq"]},{"text":"impl Eq for Tilde","synthetic":false,"types":["syn::token::Tilde"]},{"text":"impl Eq for Brace","synthetic":false,"types":["syn::token::Brace"]},{"text":"impl Eq for Bracket","synthetic":false,"types":["syn::token::Bracket"]},{"text":"impl Eq for Paren","synthetic":false,"types":["syn::token::Paren"]},{"text":"impl Eq for Group","synthetic":false,"types":["syn::token::Group"]},{"text":"impl Eq for Member","synthetic":false,"types":["syn::expr::Member"]},{"text":"impl Eq for Index","synthetic":false,"types":["syn::expr::Index"]},{"text":"impl<'a> Eq for ImplGenerics<'a>","synthetic":false,"types":["syn::generics::ImplGenerics"]},{"text":"impl<'a> Eq for TypeGenerics<'a>","synthetic":false,"types":["syn::generics::TypeGenerics"]},{"text":"impl<'a> Eq for Turbofish<'a>","synthetic":false,"types":["syn::generics::Turbofish"]},{"text":"impl Eq for Lifetime","synthetic":false,"types":["syn::lifetime::Lifetime"]},{"text":"impl<'a> Eq for Cursor<'a>","synthetic":false,"types":["syn::buffer::Cursor"]},{"text":"impl<T, P> Eq for Punctuated<T, P> where
    T: Eq,
    P: Eq, ","synthetic":false,"types":["syn::punctuated::Punctuated"]},{"text":"impl Eq for Abi","synthetic":false,"types":["syn::ty::Abi"]},{"text":"impl Eq for AngleBracketedGenericArguments","synthetic":false,"types":["syn::path::AngleBracketedGenericArguments"]},{"text":"impl Eq for AttrStyle","synthetic":false,"types":["syn::attr::AttrStyle"]},{"text":"impl Eq for Attribute","synthetic":false,"types":["syn::attr::Attribute"]},{"text":"impl Eq for BareFnArg","synthetic":false,"types":["syn::ty::BareFnArg"]},{"text":"impl Eq for BinOp","synthetic":false,"types":["syn::op::BinOp"]},{"text":"impl Eq for Binding","synthetic":false,"types":["syn::path::Binding"]},{"text":"impl Eq for BoundLifetimes","synthetic":false,"types":["syn::generics::BoundLifetimes"]},{"text":"impl Eq for ConstParam","synthetic":false,"types":["syn::generics::ConstParam"]},{"text":"impl Eq for Constraint","synthetic":false,"types":["syn::path::Constraint"]},{"text":"impl Eq for Data","synthetic":false,"types":["syn::derive::Data"]},{"text":"impl Eq for DataEnum","synthetic":false,"types":["syn::derive::DataEnum"]},{"text":"impl Eq for DataStruct","synthetic":false,"types":["syn::derive::DataStruct"]},{"text":"impl Eq for DataUnion","synthetic":false,"types":["syn::derive::DataUnion"]},{"text":"impl Eq for DeriveInput","synthetic":false,"types":["syn::derive::DeriveInput"]},{"text":"impl Eq for Expr","synthetic":false,"types":["syn::expr::Expr"]},{"text":"impl Eq for ExprBinary","synthetic":false,"types":["syn::expr::ExprBinary"]},{"text":"impl Eq for ExprCall","synthetic":false,"types":["syn::expr::ExprCall"]},{"text":"impl Eq for ExprCast","synthetic":false,"types":["syn::expr::ExprCast"]},{"text":"impl Eq for ExprField","synthetic":false,"types":["syn::expr::ExprField"]},{"text":"impl Eq for ExprIndex","synthetic":false,"types":["syn::expr::ExprIndex"]},{"text":"impl Eq for ExprLit","synthetic":false,"types":["syn::expr::ExprLit"]},{"text":"impl Eq for ExprParen","synthetic":false,"types":["syn::expr::ExprParen"]},{"text":"impl Eq for ExprPath","synthetic":false,"types":["syn::expr::ExprPath"]},{"text":"impl Eq for ExprUnary","synthetic":false,"types":["syn::expr::ExprUnary"]},{"text":"impl Eq for Field","synthetic":false,"types":["syn::data::Field"]},{"text":"impl Eq for Fields","synthetic":false,"types":["syn::data::Fields"]},{"text":"impl Eq for FieldsNamed","synthetic":false,"types":["syn::data::FieldsNamed"]},{"text":"impl Eq for FieldsUnnamed","synthetic":false,"types":["syn::data::FieldsUnnamed"]},{"text":"impl Eq for GenericArgument","synthetic":false,"types":["syn::path::GenericArgument"]},{"text":"impl Eq for GenericParam","synthetic":false,"types":["syn::generics::GenericParam"]},{"text":"impl Eq for Generics","synthetic":false,"types":["syn::generics::Generics"]},{"text":"impl Eq for LifetimeDef","synthetic":false,"types":["syn::generics::LifetimeDef"]},{"text":"impl Eq for Lit","synthetic":false,"types":["syn::lit::Lit"]},{"text":"impl Eq for LitBool","synthetic":false,"types":["syn::lit::LitBool"]},{"text":"impl Eq for LitByte","synthetic":false,"types":["syn::lit::LitByte"]},{"text":"impl Eq for LitByteStr","synthetic":false,"types":["syn::lit::LitByteStr"]},{"text":"impl Eq for LitChar","synthetic":false,"types":["syn::lit::LitChar"]},{"text":"impl Eq for LitFloat","synthetic":false,"types":["syn::lit::LitFloat"]},{"text":"impl Eq for LitInt","synthetic":false,"types":["syn::lit::LitInt"]},{"text":"impl Eq for LitStr","synthetic":false,"types":["syn::lit::LitStr"]},{"text":"impl Eq for Macro","synthetic":false,"types":["syn::mac::Macro"]},{"text":"impl Eq for MacroDelimiter","synthetic":false,"types":["syn::mac::MacroDelimiter"]},{"text":"impl Eq for Meta","synthetic":false,"types":["syn::attr::Meta"]},{"text":"impl Eq for MetaList","synthetic":false,"types":["syn::attr::MetaList"]},{"text":"impl Eq for MetaNameValue","synthetic":false,"types":["syn::attr::MetaNameValue"]},{"text":"impl Eq for NestedMeta","synthetic":false,"types":["syn::attr::NestedMeta"]},{"text":"impl Eq for ParenthesizedGenericArguments","synthetic":false,"types":["syn::path::ParenthesizedGenericArguments"]},{"text":"impl Eq for Path","synthetic":false,"types":["syn::path::Path"]},{"text":"impl Eq for PathArguments","synthetic":false,"types":["syn::path::PathArguments"]},{"text":"impl Eq for PathSegment","synthetic":false,"types":["syn::path::PathSegment"]},{"text":"impl Eq for PredicateEq","synthetic":false,"types":["syn::generics::PredicateEq"]},{"text":"impl Eq for PredicateLifetime","synthetic":false,"types":["syn::generics::PredicateLifetime"]},{"text":"impl Eq for PredicateType","synthetic":false,"types":["syn::generics::PredicateType"]},{"text":"impl Eq for QSelf","synthetic":false,"types":["syn::path::QSelf"]},{"text":"impl Eq for ReturnType","synthetic":false,"types":["syn::ty::ReturnType"]},{"text":"impl Eq for TraitBound","synthetic":false,"types":["syn::generics::TraitBound"]},{"text":"impl Eq for TraitBoundModifier","synthetic":false,"types":["syn::generics::TraitBoundModifier"]},{"text":"impl Eq for Type","synthetic":false,"types":["syn::ty::Type"]},{"text":"impl Eq for TypeArray","synthetic":false,"types":["syn::ty::TypeArray"]},{"text":"impl Eq for TypeBareFn","synthetic":false,"types":["syn::ty::TypeBareFn"]},{"text":"impl Eq for TypeGroup","synthetic":false,"types":["syn::ty::TypeGroup"]},{"text":"impl Eq for TypeImplTrait","synthetic":false,"types":["syn::ty::TypeImplTrait"]},{"text":"impl Eq for TypeInfer","synthetic":false,"types":["syn::ty::TypeInfer"]},{"text":"impl Eq for TypeMacro","synthetic":false,"types":["syn::ty::TypeMacro"]},{"text":"impl Eq for TypeNever","synthetic":false,"types":["syn::ty::TypeNever"]},{"text":"impl Eq for TypeParam","synthetic":false,"types":["syn::generics::TypeParam"]},{"text":"impl Eq for TypeParamBound","synthetic":false,"types":["syn::generics::TypeParamBound"]},{"text":"impl Eq for TypeParen","synthetic":false,"types":["syn::ty::TypeParen"]},{"text":"impl Eq for TypePath","synthetic":false,"types":["syn::ty::TypePath"]},{"text":"impl Eq for TypePtr","synthetic":false,"types":["syn::ty::TypePtr"]},{"text":"impl Eq for TypeReference","synthetic":false,"types":["syn::ty::TypeReference"]},{"text":"impl Eq for TypeSlice","synthetic":false,"types":["syn::ty::TypeSlice"]},{"text":"impl Eq for TypeTraitObject","synthetic":false,"types":["syn::ty::TypeTraitObject"]},{"text":"impl Eq for TypeTuple","synthetic":false,"types":["syn::ty::TypeTuple"]},{"text":"impl Eq for UnOp","synthetic":false,"types":["syn::op::UnOp"]},{"text":"impl Eq for Variadic","synthetic":false,"types":["syn::ty::Variadic"]},{"text":"impl Eq for Variant","synthetic":false,"types":["syn::data::Variant"]},{"text":"impl Eq for VisCrate","synthetic":false,"types":["syn::data::VisCrate"]},{"text":"impl Eq for VisPublic","synthetic":false,"types":["syn::data::VisPublic"]},{"text":"impl Eq for VisRestricted","synthetic":false,"types":["syn::data::VisRestricted"]},{"text":"impl Eq for Visibility","synthetic":false,"types":["syn::data::Visibility"]},{"text":"impl Eq for WhereClause","synthetic":false,"types":["syn::generics::WhereClause"]},{"text":"impl Eq for WherePredicate","synthetic":false,"types":["syn::generics::WherePredicate"]}]; +implementors["synstructure"] = [{"text":"impl Eq for AddBounds","synthetic":false,"types":["synstructure::AddBounds"]},{"text":"impl Eq for BindStyle","synthetic":false,"types":["synstructure::BindStyle"]},{"text":"impl<'a> Eq for BindingInfo<'a>","synthetic":false,"types":["synstructure::BindingInfo"]},{"text":"impl<'a> Eq for VariantAst<'a>","synthetic":false,"types":["synstructure::VariantAst"]},{"text":"impl<'a> Eq for VariantInfo<'a>","synthetic":false,"types":["synstructure::VariantInfo"]},{"text":"impl<'a> Eq for Structure<'a>","synthetic":false,"types":["synstructure::Structure"]}]; if (window.register_implementors) {window.register_implementors(implementors);} else {window.pending_implementors = implementors;}})() \ No newline at end of file diff --git a/implementors/core/cmp/trait.Ord.js b/implementors/core/cmp/trait.Ord.js index 4aced92..61ea18d 100644 --- a/implementors/core/cmp/trait.Ord.js +++ b/implementors/core/cmp/trait.Ord.js @@ -1,6 +1,6 @@ (function() {var implementors = {}; -implementors["flexiber"] = [{"text":"impl Ord for Length","synthetic":false,"types":[]}]; -implementors["log"] = [{"text":"impl Ord for Level","synthetic":false,"types":[]},{"text":"impl Ord for LevelFilter","synthetic":false,"types":[]},{"text":"impl<'a> Ord for Metadata<'a>","synthetic":false,"types":[]},{"text":"impl<'a> Ord for MetadataBuilder<'a>","synthetic":false,"types":[]}]; -implementors["proc_macro2"] = [{"text":"impl Ord for Ident","synthetic":false,"types":[]}]; -implementors["syn"] = [{"text":"impl Ord for Lifetime","synthetic":false,"types":[]}]; +implementors["flexiber"] = [{"text":"impl Ord for Length","synthetic":false,"types":["flexiber::length::Length"]}]; +implementors["log"] = [{"text":"impl Ord for Level","synthetic":false,"types":["log::Level"]},{"text":"impl Ord for LevelFilter","synthetic":false,"types":["log::LevelFilter"]},{"text":"impl<'a> Ord for Metadata<'a>","synthetic":false,"types":["log::Metadata"]},{"text":"impl<'a> Ord for MetadataBuilder<'a>","synthetic":false,"types":["log::MetadataBuilder"]}]; +implementors["proc_macro2"] = [{"text":"impl Ord for Ident","synthetic":false,"types":["proc_macro2::Ident"]}]; +implementors["syn"] = [{"text":"impl Ord for Lifetime","synthetic":false,"types":["syn::lifetime::Lifetime"]}]; if (window.register_implementors) {window.register_implementors(implementors);} else {window.pending_implementors = implementors;}})() \ No newline at end of file diff --git a/implementors/core/cmp/trait.PartialEq.js b/implementors/core/cmp/trait.PartialEq.js index a9e1beb..1471966 100644 --- a/implementors/core/cmp/trait.PartialEq.js +++ b/implementors/core/cmp/trait.PartialEq.js @@ -1,7 +1,7 @@ (function() {var implementors = {}; -implementors["flexiber"] = [{"text":"impl PartialEq<Error> for Error","synthetic":false,"types":[]},{"text":"impl PartialEq<ErrorKind> for ErrorKind","synthetic":false,"types":[]},{"text":"impl PartialEq<Length> for Length","synthetic":false,"types":[]},{"text":"impl PartialEq<SimpleTag> for SimpleTag","synthetic":false,"types":[]},{"text":"impl<'a> PartialEq<Slice<'a>> for Slice<'a>","synthetic":false,"types":[]},{"text":"impl PartialEq<Class> for Class","synthetic":false,"types":[]},{"text":"impl PartialEq<Tag> for Tag","synthetic":false,"types":[]},{"text":"impl<V: PartialEq, T: PartialEq> PartialEq<TaggedValue<V, T>> for TaggedValue<V, T>","synthetic":false,"types":[]}]; -implementors["log"] = [{"text":"impl PartialEq<Level> for Level","synthetic":false,"types":[]},{"text":"impl PartialEq<LevelFilter> for Level","synthetic":false,"types":[]},{"text":"impl PartialEq<LevelFilter> for LevelFilter","synthetic":false,"types":[]},{"text":"impl PartialEq<Level> for LevelFilter","synthetic":false,"types":[]},{"text":"impl<'a> PartialEq<Metadata<'a>> for Metadata<'a>","synthetic":false,"types":[]},{"text":"impl<'a> PartialEq<MetadataBuilder<'a>> for MetadataBuilder<'a>","synthetic":false,"types":[]},{"text":"impl PartialEq<ParseLevelError> for ParseLevelError","synthetic":false,"types":[]}]; -implementors["proc_macro2"] = [{"text":"impl PartialEq<Delimiter> for Delimiter","synthetic":false,"types":[]},{"text":"impl PartialEq<Spacing> for Spacing","synthetic":false,"types":[]},{"text":"impl PartialEq<Ident> for Ident","synthetic":false,"types":[]},{"text":"impl<T: ?Sized> PartialEq<T> for Ident where
    T: AsRef<str>, ","synthetic":false,"types":[]}]; -implementors["syn"] = [{"text":"impl PartialEq<Underscore> for Underscore","synthetic":false,"types":[]},{"text":"impl PartialEq<Abstract> for Abstract","synthetic":false,"types":[]},{"text":"impl PartialEq<As> for As","synthetic":false,"types":[]},{"text":"impl PartialEq<Async> for Async","synthetic":false,"types":[]},{"text":"impl PartialEq<Auto> for Auto","synthetic":false,"types":[]},{"text":"impl PartialEq<Await> for Await","synthetic":false,"types":[]},{"text":"impl PartialEq<Become> for Become","synthetic":false,"types":[]},{"text":"impl PartialEq<Box> for Box","synthetic":false,"types":[]},{"text":"impl PartialEq<Break> for Break","synthetic":false,"types":[]},{"text":"impl PartialEq<Const> for Const","synthetic":false,"types":[]},{"text":"impl PartialEq<Continue> for Continue","synthetic":false,"types":[]},{"text":"impl PartialEq<Crate> for Crate","synthetic":false,"types":[]},{"text":"impl PartialEq<Default> for Default","synthetic":false,"types":[]},{"text":"impl PartialEq<Do> for Do","synthetic":false,"types":[]},{"text":"impl PartialEq<Dyn> for Dyn","synthetic":false,"types":[]},{"text":"impl PartialEq<Else> for Else","synthetic":false,"types":[]},{"text":"impl PartialEq<Enum> for Enum","synthetic":false,"types":[]},{"text":"impl PartialEq<Extern> for Extern","synthetic":false,"types":[]},{"text":"impl PartialEq<Final> for Final","synthetic":false,"types":[]},{"text":"impl PartialEq<Fn> for Fn","synthetic":false,"types":[]},{"text":"impl PartialEq<For> for For","synthetic":false,"types":[]},{"text":"impl PartialEq<If> for If","synthetic":false,"types":[]},{"text":"impl PartialEq<Impl> for Impl","synthetic":false,"types":[]},{"text":"impl PartialEq<In> for In","synthetic":false,"types":[]},{"text":"impl PartialEq<Let> for Let","synthetic":false,"types":[]},{"text":"impl PartialEq<Loop> for Loop","synthetic":false,"types":[]},{"text":"impl PartialEq<Macro> for Macro","synthetic":false,"types":[]},{"text":"impl PartialEq<Match> for Match","synthetic":false,"types":[]},{"text":"impl PartialEq<Mod> for Mod","synthetic":false,"types":[]},{"text":"impl PartialEq<Move> for Move","synthetic":false,"types":[]},{"text":"impl PartialEq<Mut> for Mut","synthetic":false,"types":[]},{"text":"impl PartialEq<Override> for Override","synthetic":false,"types":[]},{"text":"impl PartialEq<Priv> for Priv","synthetic":false,"types":[]},{"text":"impl PartialEq<Pub> for Pub","synthetic":false,"types":[]},{"text":"impl PartialEq<Ref> for Ref","synthetic":false,"types":[]},{"text":"impl PartialEq<Return> for Return","synthetic":false,"types":[]},{"text":"impl PartialEq<SelfType> for SelfType","synthetic":false,"types":[]},{"text":"impl PartialEq<SelfValue> for SelfValue","synthetic":false,"types":[]},{"text":"impl PartialEq<Static> for Static","synthetic":false,"types":[]},{"text":"impl PartialEq<Struct> for Struct","synthetic":false,"types":[]},{"text":"impl PartialEq<Super> for Super","synthetic":false,"types":[]},{"text":"impl PartialEq<Trait> for Trait","synthetic":false,"types":[]},{"text":"impl PartialEq<Try> for Try","synthetic":false,"types":[]},{"text":"impl PartialEq<Type> for Type","synthetic":false,"types":[]},{"text":"impl PartialEq<Typeof> for Typeof","synthetic":false,"types":[]},{"text":"impl PartialEq<Union> for Union","synthetic":false,"types":[]},{"text":"impl PartialEq<Unsafe> for Unsafe","synthetic":false,"types":[]},{"text":"impl PartialEq<Unsized> for Unsized","synthetic":false,"types":[]},{"text":"impl PartialEq<Use> for Use","synthetic":false,"types":[]},{"text":"impl PartialEq<Virtual> for Virtual","synthetic":false,"types":[]},{"text":"impl PartialEq<Where> for Where","synthetic":false,"types":[]},{"text":"impl PartialEq<While> for While","synthetic":false,"types":[]},{"text":"impl PartialEq<Yield> for Yield","synthetic":false,"types":[]},{"text":"impl PartialEq<Add> for Add","synthetic":false,"types":[]},{"text":"impl PartialEq<AddEq> for AddEq","synthetic":false,"types":[]},{"text":"impl PartialEq<And> for And","synthetic":false,"types":[]},{"text":"impl PartialEq<AndAnd> for AndAnd","synthetic":false,"types":[]},{"text":"impl PartialEq<AndEq> for AndEq","synthetic":false,"types":[]},{"text":"impl PartialEq<At> for At","synthetic":false,"types":[]},{"text":"impl PartialEq<Bang> for Bang","synthetic":false,"types":[]},{"text":"impl PartialEq<Caret> for Caret","synthetic":false,"types":[]},{"text":"impl PartialEq<CaretEq> for CaretEq","synthetic":false,"types":[]},{"text":"impl PartialEq<Colon> for Colon","synthetic":false,"types":[]},{"text":"impl PartialEq<Colon2> for Colon2","synthetic":false,"types":[]},{"text":"impl PartialEq<Comma> for Comma","synthetic":false,"types":[]},{"text":"impl PartialEq<Div> for Div","synthetic":false,"types":[]},{"text":"impl PartialEq<DivEq> for DivEq","synthetic":false,"types":[]},{"text":"impl PartialEq<Dollar> for Dollar","synthetic":false,"types":[]},{"text":"impl PartialEq<Dot> for Dot","synthetic":false,"types":[]},{"text":"impl PartialEq<Dot2> for Dot2","synthetic":false,"types":[]},{"text":"impl PartialEq<Dot3> for Dot3","synthetic":false,"types":[]},{"text":"impl PartialEq<DotDotEq> for DotDotEq","synthetic":false,"types":[]},{"text":"impl PartialEq<Eq> for Eq","synthetic":false,"types":[]},{"text":"impl PartialEq<EqEq> for EqEq","synthetic":false,"types":[]},{"text":"impl PartialEq<Ge> for Ge","synthetic":false,"types":[]},{"text":"impl PartialEq<Gt> for Gt","synthetic":false,"types":[]},{"text":"impl PartialEq<Le> for Le","synthetic":false,"types":[]},{"text":"impl PartialEq<Lt> for Lt","synthetic":false,"types":[]},{"text":"impl PartialEq<MulEq> for MulEq","synthetic":false,"types":[]},{"text":"impl PartialEq<Ne> for Ne","synthetic":false,"types":[]},{"text":"impl PartialEq<Or> for Or","synthetic":false,"types":[]},{"text":"impl PartialEq<OrEq> for OrEq","synthetic":false,"types":[]},{"text":"impl PartialEq<OrOr> for OrOr","synthetic":false,"types":[]},{"text":"impl PartialEq<Pound> for Pound","synthetic":false,"types":[]},{"text":"impl PartialEq<Question> for Question","synthetic":false,"types":[]},{"text":"impl PartialEq<RArrow> for RArrow","synthetic":false,"types":[]},{"text":"impl PartialEq<LArrow> for LArrow","synthetic":false,"types":[]},{"text":"impl PartialEq<Rem> for Rem","synthetic":false,"types":[]},{"text":"impl PartialEq<RemEq> for RemEq","synthetic":false,"types":[]},{"text":"impl PartialEq<FatArrow> for FatArrow","synthetic":false,"types":[]},{"text":"impl PartialEq<Semi> for Semi","synthetic":false,"types":[]},{"text":"impl PartialEq<Shl> for Shl","synthetic":false,"types":[]},{"text":"impl PartialEq<ShlEq> for ShlEq","synthetic":false,"types":[]},{"text":"impl PartialEq<Shr> for Shr","synthetic":false,"types":[]},{"text":"impl PartialEq<ShrEq> for ShrEq","synthetic":false,"types":[]},{"text":"impl PartialEq<Star> for Star","synthetic":false,"types":[]},{"text":"impl PartialEq<Sub> for Sub","synthetic":false,"types":[]},{"text":"impl PartialEq<SubEq> for SubEq","synthetic":false,"types":[]},{"text":"impl PartialEq<Tilde> for Tilde","synthetic":false,"types":[]},{"text":"impl PartialEq<Brace> for Brace","synthetic":false,"types":[]},{"text":"impl PartialEq<Bracket> for Bracket","synthetic":false,"types":[]},{"text":"impl PartialEq<Paren> for Paren","synthetic":false,"types":[]},{"text":"impl PartialEq<Group> for Group","synthetic":false,"types":[]},{"text":"impl PartialEq<Member> for Member","synthetic":false,"types":[]},{"text":"impl PartialEq<Index> for Index","synthetic":false,"types":[]},{"text":"impl<'a> PartialEq<ImplGenerics<'a>> for ImplGenerics<'a>","synthetic":false,"types":[]},{"text":"impl<'a> PartialEq<TypeGenerics<'a>> for TypeGenerics<'a>","synthetic":false,"types":[]},{"text":"impl<'a> PartialEq<Turbofish<'a>> for Turbofish<'a>","synthetic":false,"types":[]},{"text":"impl PartialEq<Lifetime> for Lifetime","synthetic":false,"types":[]},{"text":"impl PartialEq<LitStr> for LitStr","synthetic":false,"types":[]},{"text":"impl PartialEq<LitByteStr> for LitByteStr","synthetic":false,"types":[]},{"text":"impl PartialEq<LitByte> for LitByte","synthetic":false,"types":[]},{"text":"impl PartialEq<LitChar> for LitChar","synthetic":false,"types":[]},{"text":"impl PartialEq<LitInt> for LitInt","synthetic":false,"types":[]},{"text":"impl PartialEq<LitFloat> for LitFloat","synthetic":false,"types":[]},{"text":"impl<'a> PartialEq<Cursor<'a>> for Cursor<'a>","synthetic":false,"types":[]},{"text":"impl<T, P> PartialEq<Punctuated<T, P>> for Punctuated<T, P> where
    T: PartialEq,
    P: PartialEq, ","synthetic":false,"types":[]},{"text":"impl PartialEq<Abi> for Abi","synthetic":false,"types":[]},{"text":"impl PartialEq<AngleBracketedGenericArguments> for AngleBracketedGenericArguments","synthetic":false,"types":[]},{"text":"impl PartialEq<AttrStyle> for AttrStyle","synthetic":false,"types":[]},{"text":"impl PartialEq<Attribute> for Attribute","synthetic":false,"types":[]},{"text":"impl PartialEq<BareFnArg> for BareFnArg","synthetic":false,"types":[]},{"text":"impl PartialEq<BinOp> for BinOp","synthetic":false,"types":[]},{"text":"impl PartialEq<Binding> for Binding","synthetic":false,"types":[]},{"text":"impl PartialEq<BoundLifetimes> for BoundLifetimes","synthetic":false,"types":[]},{"text":"impl PartialEq<ConstParam> for ConstParam","synthetic":false,"types":[]},{"text":"impl PartialEq<Constraint> for Constraint","synthetic":false,"types":[]},{"text":"impl PartialEq<Data> for Data","synthetic":false,"types":[]},{"text":"impl PartialEq<DataEnum> for DataEnum","synthetic":false,"types":[]},{"text":"impl PartialEq<DataStruct> for DataStruct","synthetic":false,"types":[]},{"text":"impl PartialEq<DataUnion> for DataUnion","synthetic":false,"types":[]},{"text":"impl PartialEq<DeriveInput> for DeriveInput","synthetic":false,"types":[]},{"text":"impl PartialEq<Expr> for Expr","synthetic":false,"types":[]},{"text":"impl PartialEq<ExprBinary> for ExprBinary","synthetic":false,"types":[]},{"text":"impl PartialEq<ExprCall> for ExprCall","synthetic":false,"types":[]},{"text":"impl PartialEq<ExprCast> for ExprCast","synthetic":false,"types":[]},{"text":"impl PartialEq<ExprField> for ExprField","synthetic":false,"types":[]},{"text":"impl PartialEq<ExprIndex> for ExprIndex","synthetic":false,"types":[]},{"text":"impl PartialEq<ExprLit> for ExprLit","synthetic":false,"types":[]},{"text":"impl PartialEq<ExprParen> for ExprParen","synthetic":false,"types":[]},{"text":"impl PartialEq<ExprPath> for ExprPath","synthetic":false,"types":[]},{"text":"impl PartialEq<ExprUnary> for ExprUnary","synthetic":false,"types":[]},{"text":"impl PartialEq<Field> for Field","synthetic":false,"types":[]},{"text":"impl PartialEq<Fields> for Fields","synthetic":false,"types":[]},{"text":"impl PartialEq<FieldsNamed> for FieldsNamed","synthetic":false,"types":[]},{"text":"impl PartialEq<FieldsUnnamed> for FieldsUnnamed","synthetic":false,"types":[]},{"text":"impl PartialEq<GenericArgument> for GenericArgument","synthetic":false,"types":[]},{"text":"impl PartialEq<GenericParam> for GenericParam","synthetic":false,"types":[]},{"text":"impl PartialEq<Generics> for Generics","synthetic":false,"types":[]},{"text":"impl PartialEq<LifetimeDef> for LifetimeDef","synthetic":false,"types":[]},{"text":"impl PartialEq<Lit> for Lit","synthetic":false,"types":[]},{"text":"impl PartialEq<LitBool> for LitBool","synthetic":false,"types":[]},{"text":"impl PartialEq<Macro> for Macro","synthetic":false,"types":[]},{"text":"impl PartialEq<MacroDelimiter> for MacroDelimiter","synthetic":false,"types":[]},{"text":"impl PartialEq<Meta> for Meta","synthetic":false,"types":[]},{"text":"impl PartialEq<MetaList> for MetaList","synthetic":false,"types":[]},{"text":"impl PartialEq<MetaNameValue> for MetaNameValue","synthetic":false,"types":[]},{"text":"impl PartialEq<NestedMeta> for NestedMeta","synthetic":false,"types":[]},{"text":"impl PartialEq<ParenthesizedGenericArguments> for ParenthesizedGenericArguments","synthetic":false,"types":[]},{"text":"impl PartialEq<Path> for Path","synthetic":false,"types":[]},{"text":"impl PartialEq<PathArguments> for PathArguments","synthetic":false,"types":[]},{"text":"impl PartialEq<PathSegment> for PathSegment","synthetic":false,"types":[]},{"text":"impl PartialEq<PredicateEq> for PredicateEq","synthetic":false,"types":[]},{"text":"impl PartialEq<PredicateLifetime> for PredicateLifetime","synthetic":false,"types":[]},{"text":"impl PartialEq<PredicateType> for PredicateType","synthetic":false,"types":[]},{"text":"impl PartialEq<QSelf> for QSelf","synthetic":false,"types":[]},{"text":"impl PartialEq<ReturnType> for ReturnType","synthetic":false,"types":[]},{"text":"impl PartialEq<TraitBound> for TraitBound","synthetic":false,"types":[]},{"text":"impl PartialEq<TraitBoundModifier> for TraitBoundModifier","synthetic":false,"types":[]},{"text":"impl PartialEq<Type> for Type","synthetic":false,"types":[]},{"text":"impl PartialEq<TypeArray> for TypeArray","synthetic":false,"types":[]},{"text":"impl PartialEq<TypeBareFn> for TypeBareFn","synthetic":false,"types":[]},{"text":"impl PartialEq<TypeGroup> for TypeGroup","synthetic":false,"types":[]},{"text":"impl PartialEq<TypeImplTrait> for TypeImplTrait","synthetic":false,"types":[]},{"text":"impl PartialEq<TypeInfer> for TypeInfer","synthetic":false,"types":[]},{"text":"impl PartialEq<TypeMacro> for TypeMacro","synthetic":false,"types":[]},{"text":"impl PartialEq<TypeNever> for TypeNever","synthetic":false,"types":[]},{"text":"impl PartialEq<TypeParam> for TypeParam","synthetic":false,"types":[]},{"text":"impl PartialEq<TypeParamBound> for TypeParamBound","synthetic":false,"types":[]},{"text":"impl PartialEq<TypeParen> for TypeParen","synthetic":false,"types":[]},{"text":"impl PartialEq<TypePath> for TypePath","synthetic":false,"types":[]},{"text":"impl PartialEq<TypePtr> for TypePtr","synthetic":false,"types":[]},{"text":"impl PartialEq<TypeReference> for TypeReference","synthetic":false,"types":[]},{"text":"impl PartialEq<TypeSlice> for TypeSlice","synthetic":false,"types":[]},{"text":"impl PartialEq<TypeTraitObject> for TypeTraitObject","synthetic":false,"types":[]},{"text":"impl PartialEq<TypeTuple> for TypeTuple","synthetic":false,"types":[]},{"text":"impl PartialEq<UnOp> for UnOp","synthetic":false,"types":[]},{"text":"impl PartialEq<Variadic> for Variadic","synthetic":false,"types":[]},{"text":"impl PartialEq<Variant> for Variant","synthetic":false,"types":[]},{"text":"impl PartialEq<VisCrate> for VisCrate","synthetic":false,"types":[]},{"text":"impl PartialEq<VisPublic> for VisPublic","synthetic":false,"types":[]},{"text":"impl PartialEq<VisRestricted> for VisRestricted","synthetic":false,"types":[]},{"text":"impl PartialEq<Visibility> for Visibility","synthetic":false,"types":[]},{"text":"impl PartialEq<WhereClause> for WhereClause","synthetic":false,"types":[]},{"text":"impl PartialEq<WherePredicate> for WherePredicate","synthetic":false,"types":[]}]; -implementors["synstructure"] = [{"text":"impl PartialEq<AddBounds> for AddBounds","synthetic":false,"types":[]},{"text":"impl PartialEq<BindStyle> for BindStyle","synthetic":false,"types":[]},{"text":"impl<'a> PartialEq<BindingInfo<'a>> for BindingInfo<'a>","synthetic":false,"types":[]},{"text":"impl<'a> PartialEq<VariantAst<'a>> for VariantAst<'a>","synthetic":false,"types":[]},{"text":"impl<'a> PartialEq<VariantInfo<'a>> for VariantInfo<'a>","synthetic":false,"types":[]},{"text":"impl<'a> PartialEq<Structure<'a>> for Structure<'a>","synthetic":false,"types":[]}]; +implementors["flexiber"] = [{"text":"impl PartialEq<Error> for Error","synthetic":false,"types":["flexiber::error::Error"]},{"text":"impl PartialEq<ErrorKind> for ErrorKind","synthetic":false,"types":["flexiber::error::ErrorKind"]},{"text":"impl PartialEq<Length> for Length","synthetic":false,"types":["flexiber::length::Length"]},{"text":"impl PartialEq<SimpleTag> for SimpleTag","synthetic":false,"types":["flexiber::simpletag::SimpleTag"]},{"text":"impl<'a> PartialEq<Slice<'a>> for Slice<'a>","synthetic":false,"types":["flexiber::slice::Slice"]},{"text":"impl PartialEq<Class> for Class","synthetic":false,"types":["flexiber::tag::Class"]},{"text":"impl PartialEq<Tag> for Tag","synthetic":false,"types":["flexiber::tag::Tag"]},{"text":"impl<V: PartialEq, T: PartialEq> PartialEq<TaggedValue<V, T>> for TaggedValue<V, T>","synthetic":false,"types":["flexiber::tagged::TaggedValue"]}]; +implementors["log"] = [{"text":"impl PartialEq<Level> for Level","synthetic":false,"types":["log::Level"]},{"text":"impl PartialEq<LevelFilter> for Level","synthetic":false,"types":["log::Level"]},{"text":"impl PartialEq<LevelFilter> for LevelFilter","synthetic":false,"types":["log::LevelFilter"]},{"text":"impl PartialEq<Level> for LevelFilter","synthetic":false,"types":["log::LevelFilter"]},{"text":"impl<'a> PartialEq<Metadata<'a>> for Metadata<'a>","synthetic":false,"types":["log::Metadata"]},{"text":"impl<'a> PartialEq<MetadataBuilder<'a>> for MetadataBuilder<'a>","synthetic":false,"types":["log::MetadataBuilder"]},{"text":"impl PartialEq<ParseLevelError> for ParseLevelError","synthetic":false,"types":["log::ParseLevelError"]}]; +implementors["proc_macro2"] = [{"text":"impl PartialEq<Delimiter> for Delimiter","synthetic":false,"types":["proc_macro2::Delimiter"]},{"text":"impl PartialEq<Spacing> for Spacing","synthetic":false,"types":["proc_macro2::Spacing"]},{"text":"impl PartialEq<Ident> for Ident","synthetic":false,"types":["proc_macro2::Ident"]},{"text":"impl<T: ?Sized> PartialEq<T> for Ident where
    T: AsRef<str>, ","synthetic":false,"types":["proc_macro2::Ident"]}]; +implementors["syn"] = [{"text":"impl PartialEq<Underscore> for Underscore","synthetic":false,"types":["syn::token::Underscore"]},{"text":"impl PartialEq<Abstract> for Abstract","synthetic":false,"types":["syn::token::Abstract"]},{"text":"impl PartialEq<As> for As","synthetic":false,"types":["syn::token::As"]},{"text":"impl PartialEq<Async> for Async","synthetic":false,"types":["syn::token::Async"]},{"text":"impl PartialEq<Auto> for Auto","synthetic":false,"types":["syn::token::Auto"]},{"text":"impl PartialEq<Await> for Await","synthetic":false,"types":["syn::token::Await"]},{"text":"impl PartialEq<Become> for Become","synthetic":false,"types":["syn::token::Become"]},{"text":"impl PartialEq<Box> for Box","synthetic":false,"types":["syn::token::Box"]},{"text":"impl PartialEq<Break> for Break","synthetic":false,"types":["syn::token::Break"]},{"text":"impl PartialEq<Const> for Const","synthetic":false,"types":["syn::token::Const"]},{"text":"impl PartialEq<Continue> for Continue","synthetic":false,"types":["syn::token::Continue"]},{"text":"impl PartialEq<Crate> for Crate","synthetic":false,"types":["syn::token::Crate"]},{"text":"impl PartialEq<Default> for Default","synthetic":false,"types":["syn::token::Default"]},{"text":"impl PartialEq<Do> for Do","synthetic":false,"types":["syn::token::Do"]},{"text":"impl PartialEq<Dyn> for Dyn","synthetic":false,"types":["syn::token::Dyn"]},{"text":"impl PartialEq<Else> for Else","synthetic":false,"types":["syn::token::Else"]},{"text":"impl PartialEq<Enum> for Enum","synthetic":false,"types":["syn::token::Enum"]},{"text":"impl PartialEq<Extern> for Extern","synthetic":false,"types":["syn::token::Extern"]},{"text":"impl PartialEq<Final> for Final","synthetic":false,"types":["syn::token::Final"]},{"text":"impl PartialEq<Fn> for Fn","synthetic":false,"types":["syn::token::Fn"]},{"text":"impl PartialEq<For> for For","synthetic":false,"types":["syn::token::For"]},{"text":"impl PartialEq<If> for If","synthetic":false,"types":["syn::token::If"]},{"text":"impl PartialEq<Impl> for Impl","synthetic":false,"types":["syn::token::Impl"]},{"text":"impl PartialEq<In> for In","synthetic":false,"types":["syn::token::In"]},{"text":"impl PartialEq<Let> for Let","synthetic":false,"types":["syn::token::Let"]},{"text":"impl PartialEq<Loop> for Loop","synthetic":false,"types":["syn::token::Loop"]},{"text":"impl PartialEq<Macro> for Macro","synthetic":false,"types":["syn::token::Macro"]},{"text":"impl PartialEq<Match> for Match","synthetic":false,"types":["syn::token::Match"]},{"text":"impl PartialEq<Mod> for Mod","synthetic":false,"types":["syn::token::Mod"]},{"text":"impl PartialEq<Move> for Move","synthetic":false,"types":["syn::token::Move"]},{"text":"impl PartialEq<Mut> for Mut","synthetic":false,"types":["syn::token::Mut"]},{"text":"impl PartialEq<Override> for Override","synthetic":false,"types":["syn::token::Override"]},{"text":"impl PartialEq<Priv> for Priv","synthetic":false,"types":["syn::token::Priv"]},{"text":"impl PartialEq<Pub> for Pub","synthetic":false,"types":["syn::token::Pub"]},{"text":"impl PartialEq<Ref> for Ref","synthetic":false,"types":["syn::token::Ref"]},{"text":"impl PartialEq<Return> for Return","synthetic":false,"types":["syn::token::Return"]},{"text":"impl PartialEq<SelfType> for SelfType","synthetic":false,"types":["syn::token::SelfType"]},{"text":"impl PartialEq<SelfValue> for SelfValue","synthetic":false,"types":["syn::token::SelfValue"]},{"text":"impl PartialEq<Static> for Static","synthetic":false,"types":["syn::token::Static"]},{"text":"impl PartialEq<Struct> for Struct","synthetic":false,"types":["syn::token::Struct"]},{"text":"impl PartialEq<Super> for Super","synthetic":false,"types":["syn::token::Super"]},{"text":"impl PartialEq<Trait> for Trait","synthetic":false,"types":["syn::token::Trait"]},{"text":"impl PartialEq<Try> for Try","synthetic":false,"types":["syn::token::Try"]},{"text":"impl PartialEq<Type> for Type","synthetic":false,"types":["syn::token::Type"]},{"text":"impl PartialEq<Typeof> for Typeof","synthetic":false,"types":["syn::token::Typeof"]},{"text":"impl PartialEq<Union> for Union","synthetic":false,"types":["syn::token::Union"]},{"text":"impl PartialEq<Unsafe> for Unsafe","synthetic":false,"types":["syn::token::Unsafe"]},{"text":"impl PartialEq<Unsized> for Unsized","synthetic":false,"types":["syn::token::Unsized"]},{"text":"impl PartialEq<Use> for Use","synthetic":false,"types":["syn::token::Use"]},{"text":"impl PartialEq<Virtual> for Virtual","synthetic":false,"types":["syn::token::Virtual"]},{"text":"impl PartialEq<Where> for Where","synthetic":false,"types":["syn::token::Where"]},{"text":"impl PartialEq<While> for While","synthetic":false,"types":["syn::token::While"]},{"text":"impl PartialEq<Yield> for Yield","synthetic":false,"types":["syn::token::Yield"]},{"text":"impl PartialEq<Add> for Add","synthetic":false,"types":["syn::token::Add"]},{"text":"impl PartialEq<AddEq> for AddEq","synthetic":false,"types":["syn::token::AddEq"]},{"text":"impl PartialEq<And> for And","synthetic":false,"types":["syn::token::And"]},{"text":"impl PartialEq<AndAnd> for AndAnd","synthetic":false,"types":["syn::token::AndAnd"]},{"text":"impl PartialEq<AndEq> for AndEq","synthetic":false,"types":["syn::token::AndEq"]},{"text":"impl PartialEq<At> for At","synthetic":false,"types":["syn::token::At"]},{"text":"impl PartialEq<Bang> for Bang","synthetic":false,"types":["syn::token::Bang"]},{"text":"impl PartialEq<Caret> for Caret","synthetic":false,"types":["syn::token::Caret"]},{"text":"impl PartialEq<CaretEq> for CaretEq","synthetic":false,"types":["syn::token::CaretEq"]},{"text":"impl PartialEq<Colon> for Colon","synthetic":false,"types":["syn::token::Colon"]},{"text":"impl PartialEq<Colon2> for Colon2","synthetic":false,"types":["syn::token::Colon2"]},{"text":"impl PartialEq<Comma> for Comma","synthetic":false,"types":["syn::token::Comma"]},{"text":"impl PartialEq<Div> for Div","synthetic":false,"types":["syn::token::Div"]},{"text":"impl PartialEq<DivEq> for DivEq","synthetic":false,"types":["syn::token::DivEq"]},{"text":"impl PartialEq<Dollar> for Dollar","synthetic":false,"types":["syn::token::Dollar"]},{"text":"impl PartialEq<Dot> for Dot","synthetic":false,"types":["syn::token::Dot"]},{"text":"impl PartialEq<Dot2> for Dot2","synthetic":false,"types":["syn::token::Dot2"]},{"text":"impl PartialEq<Dot3> for Dot3","synthetic":false,"types":["syn::token::Dot3"]},{"text":"impl PartialEq<DotDotEq> for DotDotEq","synthetic":false,"types":["syn::token::DotDotEq"]},{"text":"impl PartialEq<Eq> for Eq","synthetic":false,"types":["syn::token::Eq"]},{"text":"impl PartialEq<EqEq> for EqEq","synthetic":false,"types":["syn::token::EqEq"]},{"text":"impl PartialEq<Ge> for Ge","synthetic":false,"types":["syn::token::Ge"]},{"text":"impl PartialEq<Gt> for Gt","synthetic":false,"types":["syn::token::Gt"]},{"text":"impl PartialEq<Le> for Le","synthetic":false,"types":["syn::token::Le"]},{"text":"impl PartialEq<Lt> for Lt","synthetic":false,"types":["syn::token::Lt"]},{"text":"impl PartialEq<MulEq> for MulEq","synthetic":false,"types":["syn::token::MulEq"]},{"text":"impl PartialEq<Ne> for Ne","synthetic":false,"types":["syn::token::Ne"]},{"text":"impl PartialEq<Or> for Or","synthetic":false,"types":["syn::token::Or"]},{"text":"impl PartialEq<OrEq> for OrEq","synthetic":false,"types":["syn::token::OrEq"]},{"text":"impl PartialEq<OrOr> for OrOr","synthetic":false,"types":["syn::token::OrOr"]},{"text":"impl PartialEq<Pound> for Pound","synthetic":false,"types":["syn::token::Pound"]},{"text":"impl PartialEq<Question> for Question","synthetic":false,"types":["syn::token::Question"]},{"text":"impl PartialEq<RArrow> for RArrow","synthetic":false,"types":["syn::token::RArrow"]},{"text":"impl PartialEq<LArrow> for LArrow","synthetic":false,"types":["syn::token::LArrow"]},{"text":"impl PartialEq<Rem> for Rem","synthetic":false,"types":["syn::token::Rem"]},{"text":"impl PartialEq<RemEq> for RemEq","synthetic":false,"types":["syn::token::RemEq"]},{"text":"impl PartialEq<FatArrow> for FatArrow","synthetic":false,"types":["syn::token::FatArrow"]},{"text":"impl PartialEq<Semi> for Semi","synthetic":false,"types":["syn::token::Semi"]},{"text":"impl PartialEq<Shl> for Shl","synthetic":false,"types":["syn::token::Shl"]},{"text":"impl PartialEq<ShlEq> for ShlEq","synthetic":false,"types":["syn::token::ShlEq"]},{"text":"impl PartialEq<Shr> for Shr","synthetic":false,"types":["syn::token::Shr"]},{"text":"impl PartialEq<ShrEq> for ShrEq","synthetic":false,"types":["syn::token::ShrEq"]},{"text":"impl PartialEq<Star> for Star","synthetic":false,"types":["syn::token::Star"]},{"text":"impl PartialEq<Sub> for Sub","synthetic":false,"types":["syn::token::Sub"]},{"text":"impl PartialEq<SubEq> for SubEq","synthetic":false,"types":["syn::token::SubEq"]},{"text":"impl PartialEq<Tilde> for Tilde","synthetic":false,"types":["syn::token::Tilde"]},{"text":"impl PartialEq<Brace> for Brace","synthetic":false,"types":["syn::token::Brace"]},{"text":"impl PartialEq<Bracket> for Bracket","synthetic":false,"types":["syn::token::Bracket"]},{"text":"impl PartialEq<Paren> for Paren","synthetic":false,"types":["syn::token::Paren"]},{"text":"impl PartialEq<Group> for Group","synthetic":false,"types":["syn::token::Group"]},{"text":"impl PartialEq<Member> for Member","synthetic":false,"types":["syn::expr::Member"]},{"text":"impl PartialEq<Index> for Index","synthetic":false,"types":["syn::expr::Index"]},{"text":"impl<'a> PartialEq<ImplGenerics<'a>> for ImplGenerics<'a>","synthetic":false,"types":["syn::generics::ImplGenerics"]},{"text":"impl<'a> PartialEq<TypeGenerics<'a>> for TypeGenerics<'a>","synthetic":false,"types":["syn::generics::TypeGenerics"]},{"text":"impl<'a> PartialEq<Turbofish<'a>> for Turbofish<'a>","synthetic":false,"types":["syn::generics::Turbofish"]},{"text":"impl PartialEq<Lifetime> for Lifetime","synthetic":false,"types":["syn::lifetime::Lifetime"]},{"text":"impl PartialEq<LitStr> for LitStr","synthetic":false,"types":["syn::lit::LitStr"]},{"text":"impl PartialEq<LitByteStr> for LitByteStr","synthetic":false,"types":["syn::lit::LitByteStr"]},{"text":"impl PartialEq<LitByte> for LitByte","synthetic":false,"types":["syn::lit::LitByte"]},{"text":"impl PartialEq<LitChar> for LitChar","synthetic":false,"types":["syn::lit::LitChar"]},{"text":"impl PartialEq<LitInt> for LitInt","synthetic":false,"types":["syn::lit::LitInt"]},{"text":"impl PartialEq<LitFloat> for LitFloat","synthetic":false,"types":["syn::lit::LitFloat"]},{"text":"impl<'a> PartialEq<Cursor<'a>> for Cursor<'a>","synthetic":false,"types":["syn::buffer::Cursor"]},{"text":"impl<T, P> PartialEq<Punctuated<T, P>> for Punctuated<T, P> where
    T: PartialEq,
    P: PartialEq, ","synthetic":false,"types":["syn::punctuated::Punctuated"]},{"text":"impl PartialEq<Abi> for Abi","synthetic":false,"types":["syn::ty::Abi"]},{"text":"impl PartialEq<AngleBracketedGenericArguments> for AngleBracketedGenericArguments","synthetic":false,"types":["syn::path::AngleBracketedGenericArguments"]},{"text":"impl PartialEq<AttrStyle> for AttrStyle","synthetic":false,"types":["syn::attr::AttrStyle"]},{"text":"impl PartialEq<Attribute> for Attribute","synthetic":false,"types":["syn::attr::Attribute"]},{"text":"impl PartialEq<BareFnArg> for BareFnArg","synthetic":false,"types":["syn::ty::BareFnArg"]},{"text":"impl PartialEq<BinOp> for BinOp","synthetic":false,"types":["syn::op::BinOp"]},{"text":"impl PartialEq<Binding> for Binding","synthetic":false,"types":["syn::path::Binding"]},{"text":"impl PartialEq<BoundLifetimes> for BoundLifetimes","synthetic":false,"types":["syn::generics::BoundLifetimes"]},{"text":"impl PartialEq<ConstParam> for ConstParam","synthetic":false,"types":["syn::generics::ConstParam"]},{"text":"impl PartialEq<Constraint> for Constraint","synthetic":false,"types":["syn::path::Constraint"]},{"text":"impl PartialEq<Data> for Data","synthetic":false,"types":["syn::derive::Data"]},{"text":"impl PartialEq<DataEnum> for DataEnum","synthetic":false,"types":["syn::derive::DataEnum"]},{"text":"impl PartialEq<DataStruct> for DataStruct","synthetic":false,"types":["syn::derive::DataStruct"]},{"text":"impl PartialEq<DataUnion> for DataUnion","synthetic":false,"types":["syn::derive::DataUnion"]},{"text":"impl PartialEq<DeriveInput> for DeriveInput","synthetic":false,"types":["syn::derive::DeriveInput"]},{"text":"impl PartialEq<Expr> for Expr","synthetic":false,"types":["syn::expr::Expr"]},{"text":"impl PartialEq<ExprBinary> for ExprBinary","synthetic":false,"types":["syn::expr::ExprBinary"]},{"text":"impl PartialEq<ExprCall> for ExprCall","synthetic":false,"types":["syn::expr::ExprCall"]},{"text":"impl PartialEq<ExprCast> for ExprCast","synthetic":false,"types":["syn::expr::ExprCast"]},{"text":"impl PartialEq<ExprField> for ExprField","synthetic":false,"types":["syn::expr::ExprField"]},{"text":"impl PartialEq<ExprIndex> for ExprIndex","synthetic":false,"types":["syn::expr::ExprIndex"]},{"text":"impl PartialEq<ExprLit> for ExprLit","synthetic":false,"types":["syn::expr::ExprLit"]},{"text":"impl PartialEq<ExprParen> for ExprParen","synthetic":false,"types":["syn::expr::ExprParen"]},{"text":"impl PartialEq<ExprPath> for ExprPath","synthetic":false,"types":["syn::expr::ExprPath"]},{"text":"impl PartialEq<ExprUnary> for ExprUnary","synthetic":false,"types":["syn::expr::ExprUnary"]},{"text":"impl PartialEq<Field> for Field","synthetic":false,"types":["syn::data::Field"]},{"text":"impl PartialEq<Fields> for Fields","synthetic":false,"types":["syn::data::Fields"]},{"text":"impl PartialEq<FieldsNamed> for FieldsNamed","synthetic":false,"types":["syn::data::FieldsNamed"]},{"text":"impl PartialEq<FieldsUnnamed> for FieldsUnnamed","synthetic":false,"types":["syn::data::FieldsUnnamed"]},{"text":"impl PartialEq<GenericArgument> for GenericArgument","synthetic":false,"types":["syn::path::GenericArgument"]},{"text":"impl PartialEq<GenericParam> for GenericParam","synthetic":false,"types":["syn::generics::GenericParam"]},{"text":"impl PartialEq<Generics> for Generics","synthetic":false,"types":["syn::generics::Generics"]},{"text":"impl PartialEq<LifetimeDef> for LifetimeDef","synthetic":false,"types":["syn::generics::LifetimeDef"]},{"text":"impl PartialEq<Lit> for Lit","synthetic":false,"types":["syn::lit::Lit"]},{"text":"impl PartialEq<LitBool> for LitBool","synthetic":false,"types":["syn::lit::LitBool"]},{"text":"impl PartialEq<Macro> for Macro","synthetic":false,"types":["syn::mac::Macro"]},{"text":"impl PartialEq<MacroDelimiter> for MacroDelimiter","synthetic":false,"types":["syn::mac::MacroDelimiter"]},{"text":"impl PartialEq<Meta> for Meta","synthetic":false,"types":["syn::attr::Meta"]},{"text":"impl PartialEq<MetaList> for MetaList","synthetic":false,"types":["syn::attr::MetaList"]},{"text":"impl PartialEq<MetaNameValue> for MetaNameValue","synthetic":false,"types":["syn::attr::MetaNameValue"]},{"text":"impl PartialEq<NestedMeta> for NestedMeta","synthetic":false,"types":["syn::attr::NestedMeta"]},{"text":"impl PartialEq<ParenthesizedGenericArguments> for ParenthesizedGenericArguments","synthetic":false,"types":["syn::path::ParenthesizedGenericArguments"]},{"text":"impl PartialEq<Path> for Path","synthetic":false,"types":["syn::path::Path"]},{"text":"impl PartialEq<PathArguments> for PathArguments","synthetic":false,"types":["syn::path::PathArguments"]},{"text":"impl PartialEq<PathSegment> for PathSegment","synthetic":false,"types":["syn::path::PathSegment"]},{"text":"impl PartialEq<PredicateEq> for PredicateEq","synthetic":false,"types":["syn::generics::PredicateEq"]},{"text":"impl PartialEq<PredicateLifetime> for PredicateLifetime","synthetic":false,"types":["syn::generics::PredicateLifetime"]},{"text":"impl PartialEq<PredicateType> for PredicateType","synthetic":false,"types":["syn::generics::PredicateType"]},{"text":"impl PartialEq<QSelf> for QSelf","synthetic":false,"types":["syn::path::QSelf"]},{"text":"impl PartialEq<ReturnType> for ReturnType","synthetic":false,"types":["syn::ty::ReturnType"]},{"text":"impl PartialEq<TraitBound> for TraitBound","synthetic":false,"types":["syn::generics::TraitBound"]},{"text":"impl PartialEq<TraitBoundModifier> for TraitBoundModifier","synthetic":false,"types":["syn::generics::TraitBoundModifier"]},{"text":"impl PartialEq<Type> for Type","synthetic":false,"types":["syn::ty::Type"]},{"text":"impl PartialEq<TypeArray> for TypeArray","synthetic":false,"types":["syn::ty::TypeArray"]},{"text":"impl PartialEq<TypeBareFn> for TypeBareFn","synthetic":false,"types":["syn::ty::TypeBareFn"]},{"text":"impl PartialEq<TypeGroup> for TypeGroup","synthetic":false,"types":["syn::ty::TypeGroup"]},{"text":"impl PartialEq<TypeImplTrait> for TypeImplTrait","synthetic":false,"types":["syn::ty::TypeImplTrait"]},{"text":"impl PartialEq<TypeInfer> for TypeInfer","synthetic":false,"types":["syn::ty::TypeInfer"]},{"text":"impl PartialEq<TypeMacro> for TypeMacro","synthetic":false,"types":["syn::ty::TypeMacro"]},{"text":"impl PartialEq<TypeNever> for TypeNever","synthetic":false,"types":["syn::ty::TypeNever"]},{"text":"impl PartialEq<TypeParam> for TypeParam","synthetic":false,"types":["syn::generics::TypeParam"]},{"text":"impl PartialEq<TypeParamBound> for TypeParamBound","synthetic":false,"types":["syn::generics::TypeParamBound"]},{"text":"impl PartialEq<TypeParen> for TypeParen","synthetic":false,"types":["syn::ty::TypeParen"]},{"text":"impl PartialEq<TypePath> for TypePath","synthetic":false,"types":["syn::ty::TypePath"]},{"text":"impl PartialEq<TypePtr> for TypePtr","synthetic":false,"types":["syn::ty::TypePtr"]},{"text":"impl PartialEq<TypeReference> for TypeReference","synthetic":false,"types":["syn::ty::TypeReference"]},{"text":"impl PartialEq<TypeSlice> for TypeSlice","synthetic":false,"types":["syn::ty::TypeSlice"]},{"text":"impl PartialEq<TypeTraitObject> for TypeTraitObject","synthetic":false,"types":["syn::ty::TypeTraitObject"]},{"text":"impl PartialEq<TypeTuple> for TypeTuple","synthetic":false,"types":["syn::ty::TypeTuple"]},{"text":"impl PartialEq<UnOp> for UnOp","synthetic":false,"types":["syn::op::UnOp"]},{"text":"impl PartialEq<Variadic> for Variadic","synthetic":false,"types":["syn::ty::Variadic"]},{"text":"impl PartialEq<Variant> for Variant","synthetic":false,"types":["syn::data::Variant"]},{"text":"impl PartialEq<VisCrate> for VisCrate","synthetic":false,"types":["syn::data::VisCrate"]},{"text":"impl PartialEq<VisPublic> for VisPublic","synthetic":false,"types":["syn::data::VisPublic"]},{"text":"impl PartialEq<VisRestricted> for VisRestricted","synthetic":false,"types":["syn::data::VisRestricted"]},{"text":"impl PartialEq<Visibility> for Visibility","synthetic":false,"types":["syn::data::Visibility"]},{"text":"impl PartialEq<WhereClause> for WhereClause","synthetic":false,"types":["syn::generics::WhereClause"]},{"text":"impl PartialEq<WherePredicate> for WherePredicate","synthetic":false,"types":["syn::generics::WherePredicate"]}]; +implementors["synstructure"] = [{"text":"impl PartialEq<AddBounds> for AddBounds","synthetic":false,"types":["synstructure::AddBounds"]},{"text":"impl PartialEq<BindStyle> for BindStyle","synthetic":false,"types":["synstructure::BindStyle"]},{"text":"impl<'a> PartialEq<BindingInfo<'a>> for BindingInfo<'a>","synthetic":false,"types":["synstructure::BindingInfo"]},{"text":"impl<'a> PartialEq<VariantAst<'a>> for VariantAst<'a>","synthetic":false,"types":["synstructure::VariantAst"]},{"text":"impl<'a> PartialEq<VariantInfo<'a>> for VariantInfo<'a>","synthetic":false,"types":["synstructure::VariantInfo"]},{"text":"impl<'a> PartialEq<Structure<'a>> for Structure<'a>","synthetic":false,"types":["synstructure::Structure"]}]; if (window.register_implementors) {window.register_implementors(implementors);} else {window.pending_implementors = implementors;}})() \ No newline at end of file diff --git a/implementors/core/cmp/trait.PartialOrd.js b/implementors/core/cmp/trait.PartialOrd.js index 9f5ba12..fcef892 100644 --- a/implementors/core/cmp/trait.PartialOrd.js +++ b/implementors/core/cmp/trait.PartialOrd.js @@ -1,6 +1,6 @@ (function() {var implementors = {}; -implementors["flexiber"] = [{"text":"impl PartialOrd<Length> for Length","synthetic":false,"types":[]}]; -implementors["log"] = [{"text":"impl PartialOrd<Level> for Level","synthetic":false,"types":[]},{"text":"impl PartialOrd<LevelFilter> for Level","synthetic":false,"types":[]},{"text":"impl PartialOrd<LevelFilter> for LevelFilter","synthetic":false,"types":[]},{"text":"impl PartialOrd<Level> for LevelFilter","synthetic":false,"types":[]},{"text":"impl<'a> PartialOrd<Metadata<'a>> for Metadata<'a>","synthetic":false,"types":[]},{"text":"impl<'a> PartialOrd<MetadataBuilder<'a>> for MetadataBuilder<'a>","synthetic":false,"types":[]}]; -implementors["proc_macro2"] = [{"text":"impl PartialOrd<Ident> for Ident","synthetic":false,"types":[]}]; -implementors["syn"] = [{"text":"impl PartialOrd<Lifetime> for Lifetime","synthetic":false,"types":[]}]; +implementors["flexiber"] = [{"text":"impl PartialOrd<Length> for Length","synthetic":false,"types":["flexiber::length::Length"]}]; +implementors["log"] = [{"text":"impl PartialOrd<Level> for Level","synthetic":false,"types":["log::Level"]},{"text":"impl PartialOrd<LevelFilter> for Level","synthetic":false,"types":["log::Level"]},{"text":"impl PartialOrd<LevelFilter> for LevelFilter","synthetic":false,"types":["log::LevelFilter"]},{"text":"impl PartialOrd<Level> for LevelFilter","synthetic":false,"types":["log::LevelFilter"]},{"text":"impl<'a> PartialOrd<Metadata<'a>> for Metadata<'a>","synthetic":false,"types":["log::Metadata"]},{"text":"impl<'a> PartialOrd<MetadataBuilder<'a>> for MetadataBuilder<'a>","synthetic":false,"types":["log::MetadataBuilder"]}]; +implementors["proc_macro2"] = [{"text":"impl PartialOrd<Ident> for Ident","synthetic":false,"types":["proc_macro2::Ident"]}]; +implementors["syn"] = [{"text":"impl PartialOrd<Lifetime> for Lifetime","synthetic":false,"types":["syn::lifetime::Lifetime"]}]; if (window.register_implementors) {window.register_implementors(implementors);} else {window.pending_implementors = implementors;}})() \ No newline at end of file diff --git a/implementors/core/convert/trait.AsRef.js b/implementors/core/convert/trait.AsRef.js index b8cca84..43555a7 100644 --- a/implementors/core/convert/trait.AsRef.js +++ b/implementors/core/convert/trait.AsRef.js @@ -1,3 +1,3 @@ (function() {var implementors = {}; -implementors["flexiber"] = [{"text":"impl AsRef<[u8]> for Slice<'_>","synthetic":false,"types":[]}]; +implementors["flexiber"] = [{"text":"impl AsRef<[u8]> for Slice<'_>","synthetic":false,"types":["flexiber::slice::Slice"]}]; if (window.register_implementors) {window.register_implementors(implementors);} else {window.pending_implementors = implementors;}})() \ No newline at end of file diff --git a/implementors/core/convert/trait.From.js b/implementors/core/convert/trait.From.js index c82ea0c..bf1ce7f 100644 --- a/implementors/core/convert/trait.From.js +++ b/implementors/core/convert/trait.From.js @@ -1,5 +1,5 @@ (function() {var implementors = {}; -implementors["flexiber"] = [{"text":"impl<'a> From<&'a [u8]> for Decoder<'a>","synthetic":false,"types":[]},{"text":"impl From<ErrorKind> for Error","synthetic":false,"types":[]},{"text":"impl From<Infallible> for Error","synthetic":false,"types":[]},{"text":"impl From<u8> for Length","synthetic":false,"types":[]},{"text":"impl From<u16> for Length","synthetic":false,"types":[]},{"text":"impl From<Length> for u16","synthetic":false,"types":[]},{"text":"impl From<Length> for usize","synthetic":false,"types":[]}]; -implementors["proc_macro2"] = [{"text":"impl From<Span> for Span","synthetic":false,"types":[]},{"text":"impl From<TokenStream> for TokenStream","synthetic":false,"types":[]},{"text":"impl From<TokenStream> for TokenStream","synthetic":false,"types":[]},{"text":"impl From<TokenTree> for TokenStream","synthetic":false,"types":[]},{"text":"impl From<Group> for TokenTree","synthetic":false,"types":[]},{"text":"impl From<Ident> for TokenTree","synthetic":false,"types":[]},{"text":"impl From<Punct> for TokenTree","synthetic":false,"types":[]},{"text":"impl From<Literal> for TokenTree","synthetic":false,"types":[]}]; -implementors["syn"] = [{"text":"impl From<SelfValue> for Ident","synthetic":false,"types":[]},{"text":"impl From<SelfType> for Ident","synthetic":false,"types":[]},{"text":"impl From<Super> for Ident","synthetic":false,"types":[]},{"text":"impl From<Crate> for Ident","synthetic":false,"types":[]},{"text":"impl From<Extern> for Ident","synthetic":false,"types":[]},{"text":"impl From<Underscore> for Ident","synthetic":false,"types":[]},{"text":"impl From<Path> for Meta","synthetic":false,"types":[]},{"text":"impl From<MetaList> for Meta","synthetic":false,"types":[]},{"text":"impl From<MetaNameValue> for Meta","synthetic":false,"types":[]},{"text":"impl From<Meta> for NestedMeta","synthetic":false,"types":[]},{"text":"impl From<Lit> for NestedMeta","synthetic":false,"types":[]},{"text":"impl From<FieldsNamed> for Fields","synthetic":false,"types":[]},{"text":"impl From<FieldsUnnamed> for Fields","synthetic":false,"types":[]},{"text":"impl From<VisPublic> for Visibility","synthetic":false,"types":[]},{"text":"impl From<VisCrate> for Visibility","synthetic":false,"types":[]},{"text":"impl From<VisRestricted> for Visibility","synthetic":false,"types":[]},{"text":"impl From<ExprArray> for Expr","synthetic":false,"types":[]},{"text":"impl From<ExprAssign> for Expr","synthetic":false,"types":[]},{"text":"impl From<ExprAssignOp> for Expr","synthetic":false,"types":[]},{"text":"impl From<ExprAsync> for Expr","synthetic":false,"types":[]},{"text":"impl From<ExprAwait> for Expr","synthetic":false,"types":[]},{"text":"impl From<ExprBinary> for Expr","synthetic":false,"types":[]},{"text":"impl From<ExprBlock> for Expr","synthetic":false,"types":[]},{"text":"impl From<ExprBox> for Expr","synthetic":false,"types":[]},{"text":"impl From<ExprBreak> for Expr","synthetic":false,"types":[]},{"text":"impl From<ExprCall> for Expr","synthetic":false,"types":[]},{"text":"impl From<ExprCast> for Expr","synthetic":false,"types":[]},{"text":"impl From<ExprClosure> for Expr","synthetic":false,"types":[]},{"text":"impl From<ExprContinue> for Expr","synthetic":false,"types":[]},{"text":"impl From<ExprField> for Expr","synthetic":false,"types":[]},{"text":"impl From<ExprForLoop> for Expr","synthetic":false,"types":[]},{"text":"impl From<ExprGroup> for Expr","synthetic":false,"types":[]},{"text":"impl From<ExprIf> for Expr","synthetic":false,"types":[]},{"text":"impl From<ExprIndex> for Expr","synthetic":false,"types":[]},{"text":"impl From<ExprLet> for Expr","synthetic":false,"types":[]},{"text":"impl From<ExprLit> for Expr","synthetic":false,"types":[]},{"text":"impl From<ExprLoop> for Expr","synthetic":false,"types":[]},{"text":"impl From<ExprMacro> for Expr","synthetic":false,"types":[]},{"text":"impl From<ExprMatch> for Expr","synthetic":false,"types":[]},{"text":"impl From<ExprMethodCall> for Expr","synthetic":false,"types":[]},{"text":"impl From<ExprParen> for Expr","synthetic":false,"types":[]},{"text":"impl From<ExprPath> for Expr","synthetic":false,"types":[]},{"text":"impl From<ExprRange> for Expr","synthetic":false,"types":[]},{"text":"impl From<ExprReference> for Expr","synthetic":false,"types":[]},{"text":"impl From<ExprRepeat> for Expr","synthetic":false,"types":[]},{"text":"impl From<ExprReturn> for Expr","synthetic":false,"types":[]},{"text":"impl From<ExprStruct> for Expr","synthetic":false,"types":[]},{"text":"impl From<ExprTry> for Expr","synthetic":false,"types":[]},{"text":"impl From<ExprTryBlock> for Expr","synthetic":false,"types":[]},{"text":"impl From<ExprTuple> for Expr","synthetic":false,"types":[]},{"text":"impl From<ExprType> for Expr","synthetic":false,"types":[]},{"text":"impl From<ExprUnary> for Expr","synthetic":false,"types":[]},{"text":"impl From<ExprUnsafe> for Expr","synthetic":false,"types":[]},{"text":"impl From<ExprWhile> for Expr","synthetic":false,"types":[]},{"text":"impl From<ExprYield> for Expr","synthetic":false,"types":[]},{"text":"impl From<usize> for Index","synthetic":false,"types":[]},{"text":"impl From<TypeParam> for GenericParam","synthetic":false,"types":[]},{"text":"impl From<LifetimeDef> for GenericParam","synthetic":false,"types":[]},{"text":"impl From<ConstParam> for GenericParam","synthetic":false,"types":[]},{"text":"impl From<Ident> for TypeParam","synthetic":false,"types":[]},{"text":"impl From<TraitBound> for TypeParamBound","synthetic":false,"types":[]},{"text":"impl From<Lifetime> for TypeParamBound","synthetic":false,"types":[]},{"text":"impl From<PredicateType> for WherePredicate","synthetic":false,"types":[]},{"text":"impl From<PredicateLifetime> for WherePredicate","synthetic":false,"types":[]},{"text":"impl From<PredicateEq> for WherePredicate","synthetic":false,"types":[]},{"text":"impl From<LitStr> for Lit","synthetic":false,"types":[]},{"text":"impl From<LitByteStr> for Lit","synthetic":false,"types":[]},{"text":"impl From<LitByte> for Lit","synthetic":false,"types":[]},{"text":"impl From<LitChar> for Lit","synthetic":false,"types":[]},{"text":"impl From<LitInt> for Lit","synthetic":false,"types":[]},{"text":"impl From<LitFloat> for Lit","synthetic":false,"types":[]},{"text":"impl From<LitBool> for Lit","synthetic":false,"types":[]},{"text":"impl From<Literal> for LitInt","synthetic":false,"types":[]},{"text":"impl From<Literal> for LitFloat","synthetic":false,"types":[]},{"text":"impl From<DataStruct> for Data","synthetic":false,"types":[]},{"text":"impl From<DataEnum> for Data","synthetic":false,"types":[]},{"text":"impl From<DataUnion> for Data","synthetic":false,"types":[]},{"text":"impl From<TypeArray> for Type","synthetic":false,"types":[]},{"text":"impl From<TypeBareFn> for Type","synthetic":false,"types":[]},{"text":"impl From<TypeGroup> for Type","synthetic":false,"types":[]},{"text":"impl From<TypeImplTrait> for Type","synthetic":false,"types":[]},{"text":"impl From<TypeInfer> for Type","synthetic":false,"types":[]},{"text":"impl From<TypeMacro> for Type","synthetic":false,"types":[]},{"text":"impl From<TypeNever> for Type","synthetic":false,"types":[]},{"text":"impl From<TypeParen> for Type","synthetic":false,"types":[]},{"text":"impl From<TypePath> for Type","synthetic":false,"types":[]},{"text":"impl From<TypePtr> for Type","synthetic":false,"types":[]},{"text":"impl From<TypeReference> for Type","synthetic":false,"types":[]},{"text":"impl From<TypeSlice> for Type","synthetic":false,"types":[]},{"text":"impl From<TypeTraitObject> for Type","synthetic":false,"types":[]},{"text":"impl From<TypeTuple> for Type","synthetic":false,"types":[]},{"text":"impl<T> From<T> for Path where
    T: Into<PathSegment>, ","synthetic":false,"types":[]},{"text":"impl<T> From<T> for PathSegment where
    T: Into<Ident>, ","synthetic":false,"types":[]},{"text":"impl From<LexError> for Error","synthetic":false,"types":[]}]; +implementors["flexiber"] = [{"text":"impl<'a> From<&'a [u8]> for Decoder<'a>","synthetic":false,"types":["flexiber::decoder::Decoder"]},{"text":"impl From<ErrorKind> for Error","synthetic":false,"types":["flexiber::error::Error"]},{"text":"impl From<Infallible> for Error","synthetic":false,"types":["flexiber::error::Error"]},{"text":"impl From<u8> for Length","synthetic":false,"types":["flexiber::length::Length"]},{"text":"impl From<u16> for Length","synthetic":false,"types":["flexiber::length::Length"]},{"text":"impl From<Length> for u16","synthetic":false,"types":[]},{"text":"impl From<Length> for usize","synthetic":false,"types":[]}]; +implementors["proc_macro2"] = [{"text":"impl From<Span> for Span","synthetic":false,"types":["proc_macro2::Span"]},{"text":"impl From<TokenStream> for TokenStream","synthetic":false,"types":["proc_macro2::TokenStream"]},{"text":"impl From<TokenStream> for TokenStream","synthetic":false,"types":["proc_macro::TokenStream"]},{"text":"impl From<TokenTree> for TokenStream","synthetic":false,"types":["proc_macro2::TokenStream"]},{"text":"impl From<Group> for TokenTree","synthetic":false,"types":["proc_macro2::TokenTree"]},{"text":"impl From<Ident> for TokenTree","synthetic":false,"types":["proc_macro2::TokenTree"]},{"text":"impl From<Punct> for TokenTree","synthetic":false,"types":["proc_macro2::TokenTree"]},{"text":"impl From<Literal> for TokenTree","synthetic":false,"types":["proc_macro2::TokenTree"]}]; +implementors["syn"] = [{"text":"impl From<SelfValue> for Ident","synthetic":false,"types":["proc_macro2::Ident"]},{"text":"impl From<SelfType> for Ident","synthetic":false,"types":["proc_macro2::Ident"]},{"text":"impl From<Super> for Ident","synthetic":false,"types":["proc_macro2::Ident"]},{"text":"impl From<Crate> for Ident","synthetic":false,"types":["proc_macro2::Ident"]},{"text":"impl From<Extern> for Ident","synthetic":false,"types":["proc_macro2::Ident"]},{"text":"impl From<Underscore> for Ident","synthetic":false,"types":["proc_macro2::Ident"]},{"text":"impl From<Path> for Meta","synthetic":false,"types":["syn::attr::Meta"]},{"text":"impl From<MetaList> for Meta","synthetic":false,"types":["syn::attr::Meta"]},{"text":"impl From<MetaNameValue> for Meta","synthetic":false,"types":["syn::attr::Meta"]},{"text":"impl From<Meta> for NestedMeta","synthetic":false,"types":["syn::attr::NestedMeta"]},{"text":"impl From<Lit> for NestedMeta","synthetic":false,"types":["syn::attr::NestedMeta"]},{"text":"impl From<FieldsNamed> for Fields","synthetic":false,"types":["syn::data::Fields"]},{"text":"impl From<FieldsUnnamed> for Fields","synthetic":false,"types":["syn::data::Fields"]},{"text":"impl From<VisPublic> for Visibility","synthetic":false,"types":["syn::data::Visibility"]},{"text":"impl From<VisCrate> for Visibility","synthetic":false,"types":["syn::data::Visibility"]},{"text":"impl From<VisRestricted> for Visibility","synthetic":false,"types":["syn::data::Visibility"]},{"text":"impl From<ExprArray> for Expr","synthetic":false,"types":["syn::expr::Expr"]},{"text":"impl From<ExprAssign> for Expr","synthetic":false,"types":["syn::expr::Expr"]},{"text":"impl From<ExprAssignOp> for Expr","synthetic":false,"types":["syn::expr::Expr"]},{"text":"impl From<ExprAsync> for Expr","synthetic":false,"types":["syn::expr::Expr"]},{"text":"impl From<ExprAwait> for Expr","synthetic":false,"types":["syn::expr::Expr"]},{"text":"impl From<ExprBinary> for Expr","synthetic":false,"types":["syn::expr::Expr"]},{"text":"impl From<ExprBlock> for Expr","synthetic":false,"types":["syn::expr::Expr"]},{"text":"impl From<ExprBox> for Expr","synthetic":false,"types":["syn::expr::Expr"]},{"text":"impl From<ExprBreak> for Expr","synthetic":false,"types":["syn::expr::Expr"]},{"text":"impl From<ExprCall> for Expr","synthetic":false,"types":["syn::expr::Expr"]},{"text":"impl From<ExprCast> for Expr","synthetic":false,"types":["syn::expr::Expr"]},{"text":"impl From<ExprClosure> for Expr","synthetic":false,"types":["syn::expr::Expr"]},{"text":"impl From<ExprContinue> for Expr","synthetic":false,"types":["syn::expr::Expr"]},{"text":"impl From<ExprField> for Expr","synthetic":false,"types":["syn::expr::Expr"]},{"text":"impl From<ExprForLoop> for Expr","synthetic":false,"types":["syn::expr::Expr"]},{"text":"impl From<ExprGroup> for Expr","synthetic":false,"types":["syn::expr::Expr"]},{"text":"impl From<ExprIf> for Expr","synthetic":false,"types":["syn::expr::Expr"]},{"text":"impl From<ExprIndex> for Expr","synthetic":false,"types":["syn::expr::Expr"]},{"text":"impl From<ExprLet> for Expr","synthetic":false,"types":["syn::expr::Expr"]},{"text":"impl From<ExprLit> for Expr","synthetic":false,"types":["syn::expr::Expr"]},{"text":"impl From<ExprLoop> for Expr","synthetic":false,"types":["syn::expr::Expr"]},{"text":"impl From<ExprMacro> for Expr","synthetic":false,"types":["syn::expr::Expr"]},{"text":"impl From<ExprMatch> for Expr","synthetic":false,"types":["syn::expr::Expr"]},{"text":"impl From<ExprMethodCall> for Expr","synthetic":false,"types":["syn::expr::Expr"]},{"text":"impl From<ExprParen> for Expr","synthetic":false,"types":["syn::expr::Expr"]},{"text":"impl From<ExprPath> for Expr","synthetic":false,"types":["syn::expr::Expr"]},{"text":"impl From<ExprRange> for Expr","synthetic":false,"types":["syn::expr::Expr"]},{"text":"impl From<ExprReference> for Expr","synthetic":false,"types":["syn::expr::Expr"]},{"text":"impl From<ExprRepeat> for Expr","synthetic":false,"types":["syn::expr::Expr"]},{"text":"impl From<ExprReturn> for Expr","synthetic":false,"types":["syn::expr::Expr"]},{"text":"impl From<ExprStruct> for Expr","synthetic":false,"types":["syn::expr::Expr"]},{"text":"impl From<ExprTry> for Expr","synthetic":false,"types":["syn::expr::Expr"]},{"text":"impl From<ExprTryBlock> for Expr","synthetic":false,"types":["syn::expr::Expr"]},{"text":"impl From<ExprTuple> for Expr","synthetic":false,"types":["syn::expr::Expr"]},{"text":"impl From<ExprType> for Expr","synthetic":false,"types":["syn::expr::Expr"]},{"text":"impl From<ExprUnary> for Expr","synthetic":false,"types":["syn::expr::Expr"]},{"text":"impl From<ExprUnsafe> for Expr","synthetic":false,"types":["syn::expr::Expr"]},{"text":"impl From<ExprWhile> for Expr","synthetic":false,"types":["syn::expr::Expr"]},{"text":"impl From<ExprYield> for Expr","synthetic":false,"types":["syn::expr::Expr"]},{"text":"impl From<Ident> for Member","synthetic":false,"types":["syn::expr::Member"]},{"text":"impl From<Index> for Member","synthetic":false,"types":["syn::expr::Member"]},{"text":"impl From<usize> for Member","synthetic":false,"types":["syn::expr::Member"]},{"text":"impl From<usize> for Index","synthetic":false,"types":["syn::expr::Index"]},{"text":"impl From<TypeParam> for GenericParam","synthetic":false,"types":["syn::generics::GenericParam"]},{"text":"impl From<LifetimeDef> for GenericParam","synthetic":false,"types":["syn::generics::GenericParam"]},{"text":"impl From<ConstParam> for GenericParam","synthetic":false,"types":["syn::generics::GenericParam"]},{"text":"impl From<Ident> for TypeParam","synthetic":false,"types":["syn::generics::TypeParam"]},{"text":"impl From<TraitBound> for TypeParamBound","synthetic":false,"types":["syn::generics::TypeParamBound"]},{"text":"impl From<Lifetime> for TypeParamBound","synthetic":false,"types":["syn::generics::TypeParamBound"]},{"text":"impl From<PredicateType> for WherePredicate","synthetic":false,"types":["syn::generics::WherePredicate"]},{"text":"impl From<PredicateLifetime> for WherePredicate","synthetic":false,"types":["syn::generics::WherePredicate"]},{"text":"impl From<PredicateEq> for WherePredicate","synthetic":false,"types":["syn::generics::WherePredicate"]},{"text":"impl From<LitStr> for Lit","synthetic":false,"types":["syn::lit::Lit"]},{"text":"impl From<LitByteStr> for Lit","synthetic":false,"types":["syn::lit::Lit"]},{"text":"impl From<LitByte> for Lit","synthetic":false,"types":["syn::lit::Lit"]},{"text":"impl From<LitChar> for Lit","synthetic":false,"types":["syn::lit::Lit"]},{"text":"impl From<LitInt> for Lit","synthetic":false,"types":["syn::lit::Lit"]},{"text":"impl From<LitFloat> for Lit","synthetic":false,"types":["syn::lit::Lit"]},{"text":"impl From<LitBool> for Lit","synthetic":false,"types":["syn::lit::Lit"]},{"text":"impl From<Literal> for LitInt","synthetic":false,"types":["syn::lit::LitInt"]},{"text":"impl From<Literal> for LitFloat","synthetic":false,"types":["syn::lit::LitFloat"]},{"text":"impl From<DataStruct> for Data","synthetic":false,"types":["syn::derive::Data"]},{"text":"impl From<DataEnum> for Data","synthetic":false,"types":["syn::derive::Data"]},{"text":"impl From<DataUnion> for Data","synthetic":false,"types":["syn::derive::Data"]},{"text":"impl From<TypeArray> for Type","synthetic":false,"types":["syn::ty::Type"]},{"text":"impl From<TypeBareFn> for Type","synthetic":false,"types":["syn::ty::Type"]},{"text":"impl From<TypeGroup> for Type","synthetic":false,"types":["syn::ty::Type"]},{"text":"impl From<TypeImplTrait> for Type","synthetic":false,"types":["syn::ty::Type"]},{"text":"impl From<TypeInfer> for Type","synthetic":false,"types":["syn::ty::Type"]},{"text":"impl From<TypeMacro> for Type","synthetic":false,"types":["syn::ty::Type"]},{"text":"impl From<TypeNever> for Type","synthetic":false,"types":["syn::ty::Type"]},{"text":"impl From<TypeParen> for Type","synthetic":false,"types":["syn::ty::Type"]},{"text":"impl From<TypePath> for Type","synthetic":false,"types":["syn::ty::Type"]},{"text":"impl From<TypePtr> for Type","synthetic":false,"types":["syn::ty::Type"]},{"text":"impl From<TypeReference> for Type","synthetic":false,"types":["syn::ty::Type"]},{"text":"impl From<TypeSlice> for Type","synthetic":false,"types":["syn::ty::Type"]},{"text":"impl From<TypeTraitObject> for Type","synthetic":false,"types":["syn::ty::Type"]},{"text":"impl From<TypeTuple> for Type","synthetic":false,"types":["syn::ty::Type"]},{"text":"impl<T> From<T> for Path where
    T: Into<PathSegment>, ","synthetic":false,"types":["syn::path::Path"]},{"text":"impl<T> From<T> for PathSegment where
    T: Into<Ident>, ","synthetic":false,"types":["syn::path::PathSegment"]},{"text":"impl From<LexError> for Error","synthetic":false,"types":["syn::error::Error"]}]; if (window.register_implementors) {window.register_implementors(implementors);} else {window.pending_implementors = implementors;}})() \ No newline at end of file diff --git a/implementors/core/convert/trait.TryFrom.js b/implementors/core/convert/trait.TryFrom.js index 4fd8129..0167164 100644 --- a/implementors/core/convert/trait.TryFrom.js +++ b/implementors/core/convert/trait.TryFrom.js @@ -1,3 +1,3 @@ (function() {var implementors = {}; -implementors["flexiber"] = [{"text":"impl<'a> TryFrom<&'a [&'a (dyn Encodable + 'a)]> for Length","synthetic":false,"types":[]},{"text":"impl TryFrom<usize> for Length","synthetic":false,"types":[]},{"text":"impl TryFrom<u8> for SimpleTag","synthetic":false,"types":[]},{"text":"impl TryFrom<u8> for Class","synthetic":false,"types":[]},{"text":"impl TryFrom<&'_ [u8]> for Tag","synthetic":false,"types":[]},{"text":"impl TryFrom<u8> for Tag","synthetic":false,"types":[]}]; +implementors["flexiber"] = [{"text":"impl<'a> TryFrom<&'a [&'a (dyn Encodable + 'a)]> for Length","synthetic":false,"types":["flexiber::length::Length"]},{"text":"impl TryFrom<usize> for Length","synthetic":false,"types":["flexiber::length::Length"]},{"text":"impl TryFrom<u8> for SimpleTag","synthetic":false,"types":["flexiber::simpletag::SimpleTag"]},{"text":"impl TryFrom<u8> for Class","synthetic":false,"types":["flexiber::tag::Class"]},{"text":"impl TryFrom<&'_ [u8]> for Tag","synthetic":false,"types":["flexiber::tag::Tag"]},{"text":"impl TryFrom<u8> for Tag","synthetic":false,"types":["flexiber::tag::Tag"]}]; if (window.register_implementors) {window.register_implementors(implementors);} else {window.pending_implementors = implementors;}})() \ No newline at end of file diff --git a/implementors/core/default/trait.Default.js b/implementors/core/default/trait.Default.js index 0a5e602..8557a13 100644 --- a/implementors/core/default/trait.Default.js +++ b/implementors/core/default/trait.Default.js @@ -1,5 +1,5 @@ (function() {var implementors = {}; -implementors["flexiber"] = [{"text":"impl Default for Length","synthetic":false,"types":[]}]; -implementors["proc_macro2"] = [{"text":"impl Default for TokenStream","synthetic":false,"types":[]}]; -implementors["syn"] = [{"text":"impl Default for Underscore","synthetic":false,"types":[]},{"text":"impl Default for Abstract","synthetic":false,"types":[]},{"text":"impl Default for As","synthetic":false,"types":[]},{"text":"impl Default for Async","synthetic":false,"types":[]},{"text":"impl Default for Auto","synthetic":false,"types":[]},{"text":"impl Default for Await","synthetic":false,"types":[]},{"text":"impl Default for Become","synthetic":false,"types":[]},{"text":"impl Default for Box","synthetic":false,"types":[]},{"text":"impl Default for Break","synthetic":false,"types":[]},{"text":"impl Default for Const","synthetic":false,"types":[]},{"text":"impl Default for Continue","synthetic":false,"types":[]},{"text":"impl Default for Crate","synthetic":false,"types":[]},{"text":"impl Default for Default","synthetic":false,"types":[]},{"text":"impl Default for Do","synthetic":false,"types":[]},{"text":"impl Default for Dyn","synthetic":false,"types":[]},{"text":"impl Default for Else","synthetic":false,"types":[]},{"text":"impl Default for Enum","synthetic":false,"types":[]},{"text":"impl Default for Extern","synthetic":false,"types":[]},{"text":"impl Default for Final","synthetic":false,"types":[]},{"text":"impl Default for Fn","synthetic":false,"types":[]},{"text":"impl Default for For","synthetic":false,"types":[]},{"text":"impl Default for If","synthetic":false,"types":[]},{"text":"impl Default for Impl","synthetic":false,"types":[]},{"text":"impl Default for In","synthetic":false,"types":[]},{"text":"impl Default for Let","synthetic":false,"types":[]},{"text":"impl Default for Loop","synthetic":false,"types":[]},{"text":"impl Default for Macro","synthetic":false,"types":[]},{"text":"impl Default for Match","synthetic":false,"types":[]},{"text":"impl Default for Mod","synthetic":false,"types":[]},{"text":"impl Default for Move","synthetic":false,"types":[]},{"text":"impl Default for Mut","synthetic":false,"types":[]},{"text":"impl Default for Override","synthetic":false,"types":[]},{"text":"impl Default for Priv","synthetic":false,"types":[]},{"text":"impl Default for Pub","synthetic":false,"types":[]},{"text":"impl Default for Ref","synthetic":false,"types":[]},{"text":"impl Default for Return","synthetic":false,"types":[]},{"text":"impl Default for SelfType","synthetic":false,"types":[]},{"text":"impl Default for SelfValue","synthetic":false,"types":[]},{"text":"impl Default for Static","synthetic":false,"types":[]},{"text":"impl Default for Struct","synthetic":false,"types":[]},{"text":"impl Default for Super","synthetic":false,"types":[]},{"text":"impl Default for Trait","synthetic":false,"types":[]},{"text":"impl Default for Try","synthetic":false,"types":[]},{"text":"impl Default for Type","synthetic":false,"types":[]},{"text":"impl Default for Typeof","synthetic":false,"types":[]},{"text":"impl Default for Union","synthetic":false,"types":[]},{"text":"impl Default for Unsafe","synthetic":false,"types":[]},{"text":"impl Default for Unsized","synthetic":false,"types":[]},{"text":"impl Default for Use","synthetic":false,"types":[]},{"text":"impl Default for Virtual","synthetic":false,"types":[]},{"text":"impl Default for Where","synthetic":false,"types":[]},{"text":"impl Default for While","synthetic":false,"types":[]},{"text":"impl Default for Yield","synthetic":false,"types":[]},{"text":"impl Default for Add","synthetic":false,"types":[]},{"text":"impl Default for AddEq","synthetic":false,"types":[]},{"text":"impl Default for And","synthetic":false,"types":[]},{"text":"impl Default for AndAnd","synthetic":false,"types":[]},{"text":"impl Default for AndEq","synthetic":false,"types":[]},{"text":"impl Default for At","synthetic":false,"types":[]},{"text":"impl Default for Bang","synthetic":false,"types":[]},{"text":"impl Default for Caret","synthetic":false,"types":[]},{"text":"impl Default for CaretEq","synthetic":false,"types":[]},{"text":"impl Default for Colon","synthetic":false,"types":[]},{"text":"impl Default for Colon2","synthetic":false,"types":[]},{"text":"impl Default for Comma","synthetic":false,"types":[]},{"text":"impl Default for Div","synthetic":false,"types":[]},{"text":"impl Default for DivEq","synthetic":false,"types":[]},{"text":"impl Default for Dollar","synthetic":false,"types":[]},{"text":"impl Default for Dot","synthetic":false,"types":[]},{"text":"impl Default for Dot2","synthetic":false,"types":[]},{"text":"impl Default for Dot3","synthetic":false,"types":[]},{"text":"impl Default for DotDotEq","synthetic":false,"types":[]},{"text":"impl Default for Eq","synthetic":false,"types":[]},{"text":"impl Default for EqEq","synthetic":false,"types":[]},{"text":"impl Default for Ge","synthetic":false,"types":[]},{"text":"impl Default for Gt","synthetic":false,"types":[]},{"text":"impl Default for Le","synthetic":false,"types":[]},{"text":"impl Default for Lt","synthetic":false,"types":[]},{"text":"impl Default for MulEq","synthetic":false,"types":[]},{"text":"impl Default for Ne","synthetic":false,"types":[]},{"text":"impl Default for Or","synthetic":false,"types":[]},{"text":"impl Default for OrEq","synthetic":false,"types":[]},{"text":"impl Default for OrOr","synthetic":false,"types":[]},{"text":"impl Default for Pound","synthetic":false,"types":[]},{"text":"impl Default for Question","synthetic":false,"types":[]},{"text":"impl Default for RArrow","synthetic":false,"types":[]},{"text":"impl Default for LArrow","synthetic":false,"types":[]},{"text":"impl Default for Rem","synthetic":false,"types":[]},{"text":"impl Default for RemEq","synthetic":false,"types":[]},{"text":"impl Default for FatArrow","synthetic":false,"types":[]},{"text":"impl Default for Semi","synthetic":false,"types":[]},{"text":"impl Default for Shl","synthetic":false,"types":[]},{"text":"impl Default for ShlEq","synthetic":false,"types":[]},{"text":"impl Default for Shr","synthetic":false,"types":[]},{"text":"impl Default for ShrEq","synthetic":false,"types":[]},{"text":"impl Default for Star","synthetic":false,"types":[]},{"text":"impl Default for Sub","synthetic":false,"types":[]},{"text":"impl Default for SubEq","synthetic":false,"types":[]},{"text":"impl Default for Tilde","synthetic":false,"types":[]},{"text":"impl Default for Brace","synthetic":false,"types":[]},{"text":"impl Default for Bracket","synthetic":false,"types":[]},{"text":"impl Default for Paren","synthetic":false,"types":[]},{"text":"impl Default for Group","synthetic":false,"types":[]},{"text":"impl Default for Generics","synthetic":false,"types":[]},{"text":"impl Default for BoundLifetimes","synthetic":false,"types":[]},{"text":"impl Default for PathArguments","synthetic":false,"types":[]},{"text":"impl<T, P> Default for Punctuated<T, P>","synthetic":false,"types":[]}]; +implementors["flexiber"] = [{"text":"impl Default for Length","synthetic":false,"types":["flexiber::length::Length"]}]; +implementors["proc_macro2"] = [{"text":"impl Default for TokenStream","synthetic":false,"types":["proc_macro2::TokenStream"]}]; +implementors["syn"] = [{"text":"impl Default for Underscore","synthetic":false,"types":["syn::token::Underscore"]},{"text":"impl Default for Abstract","synthetic":false,"types":["syn::token::Abstract"]},{"text":"impl Default for As","synthetic":false,"types":["syn::token::As"]},{"text":"impl Default for Async","synthetic":false,"types":["syn::token::Async"]},{"text":"impl Default for Auto","synthetic":false,"types":["syn::token::Auto"]},{"text":"impl Default for Await","synthetic":false,"types":["syn::token::Await"]},{"text":"impl Default for Become","synthetic":false,"types":["syn::token::Become"]},{"text":"impl Default for Box","synthetic":false,"types":["syn::token::Box"]},{"text":"impl Default for Break","synthetic":false,"types":["syn::token::Break"]},{"text":"impl Default for Const","synthetic":false,"types":["syn::token::Const"]},{"text":"impl Default for Continue","synthetic":false,"types":["syn::token::Continue"]},{"text":"impl Default for Crate","synthetic":false,"types":["syn::token::Crate"]},{"text":"impl Default for Default","synthetic":false,"types":["syn::token::Default"]},{"text":"impl Default for Do","synthetic":false,"types":["syn::token::Do"]},{"text":"impl Default for Dyn","synthetic":false,"types":["syn::token::Dyn"]},{"text":"impl Default for Else","synthetic":false,"types":["syn::token::Else"]},{"text":"impl Default for Enum","synthetic":false,"types":["syn::token::Enum"]},{"text":"impl Default for Extern","synthetic":false,"types":["syn::token::Extern"]},{"text":"impl Default for Final","synthetic":false,"types":["syn::token::Final"]},{"text":"impl Default for Fn","synthetic":false,"types":["syn::token::Fn"]},{"text":"impl Default for For","synthetic":false,"types":["syn::token::For"]},{"text":"impl Default for If","synthetic":false,"types":["syn::token::If"]},{"text":"impl Default for Impl","synthetic":false,"types":["syn::token::Impl"]},{"text":"impl Default for In","synthetic":false,"types":["syn::token::In"]},{"text":"impl Default for Let","synthetic":false,"types":["syn::token::Let"]},{"text":"impl Default for Loop","synthetic":false,"types":["syn::token::Loop"]},{"text":"impl Default for Macro","synthetic":false,"types":["syn::token::Macro"]},{"text":"impl Default for Match","synthetic":false,"types":["syn::token::Match"]},{"text":"impl Default for Mod","synthetic":false,"types":["syn::token::Mod"]},{"text":"impl Default for Move","synthetic":false,"types":["syn::token::Move"]},{"text":"impl Default for Mut","synthetic":false,"types":["syn::token::Mut"]},{"text":"impl Default for Override","synthetic":false,"types":["syn::token::Override"]},{"text":"impl Default for Priv","synthetic":false,"types":["syn::token::Priv"]},{"text":"impl Default for Pub","synthetic":false,"types":["syn::token::Pub"]},{"text":"impl Default for Ref","synthetic":false,"types":["syn::token::Ref"]},{"text":"impl Default for Return","synthetic":false,"types":["syn::token::Return"]},{"text":"impl Default for SelfType","synthetic":false,"types":["syn::token::SelfType"]},{"text":"impl Default for SelfValue","synthetic":false,"types":["syn::token::SelfValue"]},{"text":"impl Default for Static","synthetic":false,"types":["syn::token::Static"]},{"text":"impl Default for Struct","synthetic":false,"types":["syn::token::Struct"]},{"text":"impl Default for Super","synthetic":false,"types":["syn::token::Super"]},{"text":"impl Default for Trait","synthetic":false,"types":["syn::token::Trait"]},{"text":"impl Default for Try","synthetic":false,"types":["syn::token::Try"]},{"text":"impl Default for Type","synthetic":false,"types":["syn::token::Type"]},{"text":"impl Default for Typeof","synthetic":false,"types":["syn::token::Typeof"]},{"text":"impl Default for Union","synthetic":false,"types":["syn::token::Union"]},{"text":"impl Default for Unsafe","synthetic":false,"types":["syn::token::Unsafe"]},{"text":"impl Default for Unsized","synthetic":false,"types":["syn::token::Unsized"]},{"text":"impl Default for Use","synthetic":false,"types":["syn::token::Use"]},{"text":"impl Default for Virtual","synthetic":false,"types":["syn::token::Virtual"]},{"text":"impl Default for Where","synthetic":false,"types":["syn::token::Where"]},{"text":"impl Default for While","synthetic":false,"types":["syn::token::While"]},{"text":"impl Default for Yield","synthetic":false,"types":["syn::token::Yield"]},{"text":"impl Default for Add","synthetic":false,"types":["syn::token::Add"]},{"text":"impl Default for AddEq","synthetic":false,"types":["syn::token::AddEq"]},{"text":"impl Default for And","synthetic":false,"types":["syn::token::And"]},{"text":"impl Default for AndAnd","synthetic":false,"types":["syn::token::AndAnd"]},{"text":"impl Default for AndEq","synthetic":false,"types":["syn::token::AndEq"]},{"text":"impl Default for At","synthetic":false,"types":["syn::token::At"]},{"text":"impl Default for Bang","synthetic":false,"types":["syn::token::Bang"]},{"text":"impl Default for Caret","synthetic":false,"types":["syn::token::Caret"]},{"text":"impl Default for CaretEq","synthetic":false,"types":["syn::token::CaretEq"]},{"text":"impl Default for Colon","synthetic":false,"types":["syn::token::Colon"]},{"text":"impl Default for Colon2","synthetic":false,"types":["syn::token::Colon2"]},{"text":"impl Default for Comma","synthetic":false,"types":["syn::token::Comma"]},{"text":"impl Default for Div","synthetic":false,"types":["syn::token::Div"]},{"text":"impl Default for DivEq","synthetic":false,"types":["syn::token::DivEq"]},{"text":"impl Default for Dollar","synthetic":false,"types":["syn::token::Dollar"]},{"text":"impl Default for Dot","synthetic":false,"types":["syn::token::Dot"]},{"text":"impl Default for Dot2","synthetic":false,"types":["syn::token::Dot2"]},{"text":"impl Default for Dot3","synthetic":false,"types":["syn::token::Dot3"]},{"text":"impl Default for DotDotEq","synthetic":false,"types":["syn::token::DotDotEq"]},{"text":"impl Default for Eq","synthetic":false,"types":["syn::token::Eq"]},{"text":"impl Default for EqEq","synthetic":false,"types":["syn::token::EqEq"]},{"text":"impl Default for Ge","synthetic":false,"types":["syn::token::Ge"]},{"text":"impl Default for Gt","synthetic":false,"types":["syn::token::Gt"]},{"text":"impl Default for Le","synthetic":false,"types":["syn::token::Le"]},{"text":"impl Default for Lt","synthetic":false,"types":["syn::token::Lt"]},{"text":"impl Default for MulEq","synthetic":false,"types":["syn::token::MulEq"]},{"text":"impl Default for Ne","synthetic":false,"types":["syn::token::Ne"]},{"text":"impl Default for Or","synthetic":false,"types":["syn::token::Or"]},{"text":"impl Default for OrEq","synthetic":false,"types":["syn::token::OrEq"]},{"text":"impl Default for OrOr","synthetic":false,"types":["syn::token::OrOr"]},{"text":"impl Default for Pound","synthetic":false,"types":["syn::token::Pound"]},{"text":"impl Default for Question","synthetic":false,"types":["syn::token::Question"]},{"text":"impl Default for RArrow","synthetic":false,"types":["syn::token::RArrow"]},{"text":"impl Default for LArrow","synthetic":false,"types":["syn::token::LArrow"]},{"text":"impl Default for Rem","synthetic":false,"types":["syn::token::Rem"]},{"text":"impl Default for RemEq","synthetic":false,"types":["syn::token::RemEq"]},{"text":"impl Default for FatArrow","synthetic":false,"types":["syn::token::FatArrow"]},{"text":"impl Default for Semi","synthetic":false,"types":["syn::token::Semi"]},{"text":"impl Default for Shl","synthetic":false,"types":["syn::token::Shl"]},{"text":"impl Default for ShlEq","synthetic":false,"types":["syn::token::ShlEq"]},{"text":"impl Default for Shr","synthetic":false,"types":["syn::token::Shr"]},{"text":"impl Default for ShrEq","synthetic":false,"types":["syn::token::ShrEq"]},{"text":"impl Default for Star","synthetic":false,"types":["syn::token::Star"]},{"text":"impl Default for Sub","synthetic":false,"types":["syn::token::Sub"]},{"text":"impl Default for SubEq","synthetic":false,"types":["syn::token::SubEq"]},{"text":"impl Default for Tilde","synthetic":false,"types":["syn::token::Tilde"]},{"text":"impl Default for Brace","synthetic":false,"types":["syn::token::Brace"]},{"text":"impl Default for Bracket","synthetic":false,"types":["syn::token::Bracket"]},{"text":"impl Default for Paren","synthetic":false,"types":["syn::token::Paren"]},{"text":"impl Default for Group","synthetic":false,"types":["syn::token::Group"]},{"text":"impl Default for Generics","synthetic":false,"types":["syn::generics::Generics"]},{"text":"impl Default for BoundLifetimes","synthetic":false,"types":["syn::generics::BoundLifetimes"]},{"text":"impl Default for PathArguments","synthetic":false,"types":["syn::path::PathArguments"]},{"text":"impl<T, P> Default for Punctuated<T, P>","synthetic":false,"types":["syn::punctuated::Punctuated"]}]; if (window.register_implementors) {window.register_implementors(implementors);} else {window.pending_implementors = implementors;}})() \ No newline at end of file diff --git a/implementors/core/fmt/trait.Debug.js b/implementors/core/fmt/trait.Debug.js index 362182d..26a827e 100644 --- a/implementors/core/fmt/trait.Debug.js +++ b/implementors/core/fmt/trait.Debug.js @@ -1,8 +1,8 @@ (function() {var implementors = {}; -implementors["delog"] = [{"text":"impl<T: ?Sized, S, U> Debug for HexStr<'_, T, U, S> where
    T: AsRef<[u8]>,
    U: Unsigned,
    S: Separator, ","synthetic":false,"types":[]},{"text":"impl Debug for Statistics","synthetic":false,"types":[]}]; -implementors["flexiber"] = [{"text":"impl<'a> Debug for Decoder<'a>","synthetic":false,"types":[]},{"text":"impl<'a> Debug for Encoder<'a>","synthetic":false,"types":[]},{"text":"impl Debug for Error","synthetic":false,"types":[]},{"text":"impl Debug for ErrorKind","synthetic":false,"types":[]},{"text":"impl Debug for Length","synthetic":false,"types":[]},{"text":"impl<'a> Debug for Slice<'a>","synthetic":false,"types":[]},{"text":"impl Debug for Class","synthetic":false,"types":[]},{"text":"impl Debug for Tag","synthetic":false,"types":[]},{"text":"impl<V: Debug, T: Debug> Debug for TaggedValue<V, T>","synthetic":false,"types":[]}]; -implementors["log"] = [{"text":"impl Debug for Level","synthetic":false,"types":[]},{"text":"impl Debug for LevelFilter","synthetic":false,"types":[]},{"text":"impl<'a> Debug for Record<'a>","synthetic":false,"types":[]},{"text":"impl<'a> Debug for RecordBuilder<'a>","synthetic":false,"types":[]},{"text":"impl<'a> Debug for Metadata<'a>","synthetic":false,"types":[]},{"text":"impl<'a> Debug for MetadataBuilder<'a>","synthetic":false,"types":[]},{"text":"impl Debug for SetLoggerError","synthetic":false,"types":[]},{"text":"impl Debug for ParseLevelError","synthetic":false,"types":[]}]; -implementors["proc_macro2"] = [{"text":"impl Debug for TokenStream","synthetic":false,"types":[]},{"text":"impl Debug for LexError","synthetic":false,"types":[]},{"text":"impl Debug for Span","synthetic":false,"types":[]},{"text":"impl Debug for TokenTree","synthetic":false,"types":[]},{"text":"impl Debug for Delimiter","synthetic":false,"types":[]},{"text":"impl Debug for Group","synthetic":false,"types":[]},{"text":"impl Debug for Spacing","synthetic":false,"types":[]},{"text":"impl Debug for Punct","synthetic":false,"types":[]},{"text":"impl Debug for Ident","synthetic":false,"types":[]},{"text":"impl Debug for Literal","synthetic":false,"types":[]},{"text":"impl Debug for IntoIter","synthetic":false,"types":[]}]; -implementors["syn"] = [{"text":"impl Debug for Underscore","synthetic":false,"types":[]},{"text":"impl Debug for Abstract","synthetic":false,"types":[]},{"text":"impl Debug for As","synthetic":false,"types":[]},{"text":"impl Debug for Async","synthetic":false,"types":[]},{"text":"impl Debug for Auto","synthetic":false,"types":[]},{"text":"impl Debug for Await","synthetic":false,"types":[]},{"text":"impl Debug for Become","synthetic":false,"types":[]},{"text":"impl Debug for Box","synthetic":false,"types":[]},{"text":"impl Debug for Break","synthetic":false,"types":[]},{"text":"impl Debug for Const","synthetic":false,"types":[]},{"text":"impl Debug for Continue","synthetic":false,"types":[]},{"text":"impl Debug for Crate","synthetic":false,"types":[]},{"text":"impl Debug for Default","synthetic":false,"types":[]},{"text":"impl Debug for Do","synthetic":false,"types":[]},{"text":"impl Debug for Dyn","synthetic":false,"types":[]},{"text":"impl Debug for Else","synthetic":false,"types":[]},{"text":"impl Debug for Enum","synthetic":false,"types":[]},{"text":"impl Debug for Extern","synthetic":false,"types":[]},{"text":"impl Debug for Final","synthetic":false,"types":[]},{"text":"impl Debug for Fn","synthetic":false,"types":[]},{"text":"impl Debug for For","synthetic":false,"types":[]},{"text":"impl Debug for If","synthetic":false,"types":[]},{"text":"impl Debug for Impl","synthetic":false,"types":[]},{"text":"impl Debug for In","synthetic":false,"types":[]},{"text":"impl Debug for Let","synthetic":false,"types":[]},{"text":"impl Debug for Loop","synthetic":false,"types":[]},{"text":"impl Debug for Macro","synthetic":false,"types":[]},{"text":"impl Debug for Match","synthetic":false,"types":[]},{"text":"impl Debug for Mod","synthetic":false,"types":[]},{"text":"impl Debug for Move","synthetic":false,"types":[]},{"text":"impl Debug for Mut","synthetic":false,"types":[]},{"text":"impl Debug for Override","synthetic":false,"types":[]},{"text":"impl Debug for Priv","synthetic":false,"types":[]},{"text":"impl Debug for Pub","synthetic":false,"types":[]},{"text":"impl Debug for Ref","synthetic":false,"types":[]},{"text":"impl Debug for Return","synthetic":false,"types":[]},{"text":"impl Debug for SelfType","synthetic":false,"types":[]},{"text":"impl Debug for SelfValue","synthetic":false,"types":[]},{"text":"impl Debug for Static","synthetic":false,"types":[]},{"text":"impl Debug for Struct","synthetic":false,"types":[]},{"text":"impl Debug for Super","synthetic":false,"types":[]},{"text":"impl Debug for Trait","synthetic":false,"types":[]},{"text":"impl Debug for Try","synthetic":false,"types":[]},{"text":"impl Debug for Type","synthetic":false,"types":[]},{"text":"impl Debug for Typeof","synthetic":false,"types":[]},{"text":"impl Debug for Union","synthetic":false,"types":[]},{"text":"impl Debug for Unsafe","synthetic":false,"types":[]},{"text":"impl Debug for Unsized","synthetic":false,"types":[]},{"text":"impl Debug for Use","synthetic":false,"types":[]},{"text":"impl Debug for Virtual","synthetic":false,"types":[]},{"text":"impl Debug for Where","synthetic":false,"types":[]},{"text":"impl Debug for While","synthetic":false,"types":[]},{"text":"impl Debug for Yield","synthetic":false,"types":[]},{"text":"impl Debug for Add","synthetic":false,"types":[]},{"text":"impl Debug for AddEq","synthetic":false,"types":[]},{"text":"impl Debug for And","synthetic":false,"types":[]},{"text":"impl Debug for AndAnd","synthetic":false,"types":[]},{"text":"impl Debug for AndEq","synthetic":false,"types":[]},{"text":"impl Debug for At","synthetic":false,"types":[]},{"text":"impl Debug for Bang","synthetic":false,"types":[]},{"text":"impl Debug for Caret","synthetic":false,"types":[]},{"text":"impl Debug for CaretEq","synthetic":false,"types":[]},{"text":"impl Debug for Colon","synthetic":false,"types":[]},{"text":"impl Debug for Colon2","synthetic":false,"types":[]},{"text":"impl Debug for Comma","synthetic":false,"types":[]},{"text":"impl Debug for Div","synthetic":false,"types":[]},{"text":"impl Debug for DivEq","synthetic":false,"types":[]},{"text":"impl Debug for Dollar","synthetic":false,"types":[]},{"text":"impl Debug for Dot","synthetic":false,"types":[]},{"text":"impl Debug for Dot2","synthetic":false,"types":[]},{"text":"impl Debug for Dot3","synthetic":false,"types":[]},{"text":"impl Debug for DotDotEq","synthetic":false,"types":[]},{"text":"impl Debug for Eq","synthetic":false,"types":[]},{"text":"impl Debug for EqEq","synthetic":false,"types":[]},{"text":"impl Debug for Ge","synthetic":false,"types":[]},{"text":"impl Debug for Gt","synthetic":false,"types":[]},{"text":"impl Debug for Le","synthetic":false,"types":[]},{"text":"impl Debug for Lt","synthetic":false,"types":[]},{"text":"impl Debug for MulEq","synthetic":false,"types":[]},{"text":"impl Debug for Ne","synthetic":false,"types":[]},{"text":"impl Debug for Or","synthetic":false,"types":[]},{"text":"impl Debug for OrEq","synthetic":false,"types":[]},{"text":"impl Debug for OrOr","synthetic":false,"types":[]},{"text":"impl Debug for Pound","synthetic":false,"types":[]},{"text":"impl Debug for Question","synthetic":false,"types":[]},{"text":"impl Debug for RArrow","synthetic":false,"types":[]},{"text":"impl Debug for LArrow","synthetic":false,"types":[]},{"text":"impl Debug for Rem","synthetic":false,"types":[]},{"text":"impl Debug for RemEq","synthetic":false,"types":[]},{"text":"impl Debug for FatArrow","synthetic":false,"types":[]},{"text":"impl Debug for Semi","synthetic":false,"types":[]},{"text":"impl Debug for Shl","synthetic":false,"types":[]},{"text":"impl Debug for ShlEq","synthetic":false,"types":[]},{"text":"impl Debug for Shr","synthetic":false,"types":[]},{"text":"impl Debug for ShrEq","synthetic":false,"types":[]},{"text":"impl Debug for Star","synthetic":false,"types":[]},{"text":"impl Debug for Sub","synthetic":false,"types":[]},{"text":"impl Debug for SubEq","synthetic":false,"types":[]},{"text":"impl Debug for Tilde","synthetic":false,"types":[]},{"text":"impl Debug for Brace","synthetic":false,"types":[]},{"text":"impl Debug for Bracket","synthetic":false,"types":[]},{"text":"impl Debug for Paren","synthetic":false,"types":[]},{"text":"impl Debug for Group","synthetic":false,"types":[]},{"text":"impl<'a> Debug for ImplGenerics<'a>","synthetic":false,"types":[]},{"text":"impl<'a> Debug for TypeGenerics<'a>","synthetic":false,"types":[]},{"text":"impl<'a> Debug for Turbofish<'a>","synthetic":false,"types":[]},{"text":"impl Debug for LitStr","synthetic":false,"types":[]},{"text":"impl Debug for LitByteStr","synthetic":false,"types":[]},{"text":"impl Debug for LitByte","synthetic":false,"types":[]},{"text":"impl Debug for LitChar","synthetic":false,"types":[]},{"text":"impl Debug for LitInt","synthetic":false,"types":[]},{"text":"impl Debug for LitFloat","synthetic":false,"types":[]},{"text":"impl Debug for LitBool","synthetic":false,"types":[]},{"text":"impl<T: Debug, P: Debug> Debug for Punctuated<T, P>","synthetic":false,"types":[]},{"text":"impl Debug for Abi","synthetic":false,"types":[]},{"text":"impl Debug for AngleBracketedGenericArguments","synthetic":false,"types":[]},{"text":"impl Debug for AttrStyle","synthetic":false,"types":[]},{"text":"impl Debug for Attribute","synthetic":false,"types":[]},{"text":"impl Debug for BareFnArg","synthetic":false,"types":[]},{"text":"impl Debug for BinOp","synthetic":false,"types":[]},{"text":"impl Debug for Binding","synthetic":false,"types":[]},{"text":"impl Debug for BoundLifetimes","synthetic":false,"types":[]},{"text":"impl Debug for ConstParam","synthetic":false,"types":[]},{"text":"impl Debug for Constraint","synthetic":false,"types":[]},{"text":"impl Debug for Data","synthetic":false,"types":[]},{"text":"impl Debug for DataEnum","synthetic":false,"types":[]},{"text":"impl Debug for DataStruct","synthetic":false,"types":[]},{"text":"impl Debug for DataUnion","synthetic":false,"types":[]},{"text":"impl Debug for DeriveInput","synthetic":false,"types":[]},{"text":"impl Debug for Expr","synthetic":false,"types":[]},{"text":"impl Debug for ExprBinary","synthetic":false,"types":[]},{"text":"impl Debug for ExprCall","synthetic":false,"types":[]},{"text":"impl Debug for ExprCast","synthetic":false,"types":[]},{"text":"impl Debug for ExprField","synthetic":false,"types":[]},{"text":"impl Debug for ExprIndex","synthetic":false,"types":[]},{"text":"impl Debug for ExprLit","synthetic":false,"types":[]},{"text":"impl Debug for ExprParen","synthetic":false,"types":[]},{"text":"impl Debug for ExprPath","synthetic":false,"types":[]},{"text":"impl Debug for ExprUnary","synthetic":false,"types":[]},{"text":"impl Debug for Field","synthetic":false,"types":[]},{"text":"impl Debug for Fields","synthetic":false,"types":[]},{"text":"impl Debug for FieldsNamed","synthetic":false,"types":[]},{"text":"impl Debug for FieldsUnnamed","synthetic":false,"types":[]},{"text":"impl Debug for GenericArgument","synthetic":false,"types":[]},{"text":"impl Debug for GenericParam","synthetic":false,"types":[]},{"text":"impl Debug for Generics","synthetic":false,"types":[]},{"text":"impl Debug for Index","synthetic":false,"types":[]},{"text":"impl Debug for Lifetime","synthetic":false,"types":[]},{"text":"impl Debug for LifetimeDef","synthetic":false,"types":[]},{"text":"impl Debug for Lit","synthetic":false,"types":[]},{"text":"impl Debug for Macro","synthetic":false,"types":[]},{"text":"impl Debug for MacroDelimiter","synthetic":false,"types":[]},{"text":"impl Debug for Member","synthetic":false,"types":[]},{"text":"impl Debug for Meta","synthetic":false,"types":[]},{"text":"impl Debug for MetaList","synthetic":false,"types":[]},{"text":"impl Debug for MetaNameValue","synthetic":false,"types":[]},{"text":"impl Debug for NestedMeta","synthetic":false,"types":[]},{"text":"impl Debug for ParenthesizedGenericArguments","synthetic":false,"types":[]},{"text":"impl Debug for Path","synthetic":false,"types":[]},{"text":"impl Debug for PathArguments","synthetic":false,"types":[]},{"text":"impl Debug for PathSegment","synthetic":false,"types":[]},{"text":"impl Debug for PredicateEq","synthetic":false,"types":[]},{"text":"impl Debug for PredicateLifetime","synthetic":false,"types":[]},{"text":"impl Debug for PredicateType","synthetic":false,"types":[]},{"text":"impl Debug for QSelf","synthetic":false,"types":[]},{"text":"impl Debug for ReturnType","synthetic":false,"types":[]},{"text":"impl Debug for TraitBound","synthetic":false,"types":[]},{"text":"impl Debug for TraitBoundModifier","synthetic":false,"types":[]},{"text":"impl Debug for Type","synthetic":false,"types":[]},{"text":"impl Debug for TypeArray","synthetic":false,"types":[]},{"text":"impl Debug for TypeBareFn","synthetic":false,"types":[]},{"text":"impl Debug for TypeGroup","synthetic":false,"types":[]},{"text":"impl Debug for TypeImplTrait","synthetic":false,"types":[]},{"text":"impl Debug for TypeInfer","synthetic":false,"types":[]},{"text":"impl Debug for TypeMacro","synthetic":false,"types":[]},{"text":"impl Debug for TypeNever","synthetic":false,"types":[]},{"text":"impl Debug for TypeParam","synthetic":false,"types":[]},{"text":"impl Debug for TypeParamBound","synthetic":false,"types":[]},{"text":"impl Debug for TypeParen","synthetic":false,"types":[]},{"text":"impl Debug for TypePath","synthetic":false,"types":[]},{"text":"impl Debug for TypePtr","synthetic":false,"types":[]},{"text":"impl Debug for TypeReference","synthetic":false,"types":[]},{"text":"impl Debug for TypeSlice","synthetic":false,"types":[]},{"text":"impl Debug for TypeTraitObject","synthetic":false,"types":[]},{"text":"impl Debug for TypeTuple","synthetic":false,"types":[]},{"text":"impl Debug for UnOp","synthetic":false,"types":[]},{"text":"impl Debug for Variadic","synthetic":false,"types":[]},{"text":"impl Debug for Variant","synthetic":false,"types":[]},{"text":"impl Debug for VisCrate","synthetic":false,"types":[]},{"text":"impl Debug for VisPublic","synthetic":false,"types":[]},{"text":"impl Debug for VisRestricted","synthetic":false,"types":[]},{"text":"impl Debug for Visibility","synthetic":false,"types":[]},{"text":"impl Debug for WhereClause","synthetic":false,"types":[]},{"text":"impl Debug for WherePredicate","synthetic":false,"types":[]},{"text":"impl<'a> Debug for ParseBuffer<'a>","synthetic":false,"types":[]},{"text":"impl Debug for Error","synthetic":false,"types":[]}]; -implementors["synstructure"] = [{"text":"impl Debug for AddBounds","synthetic":false,"types":[]},{"text":"impl Debug for BindStyle","synthetic":false,"types":[]},{"text":"impl<'a> Debug for BindingInfo<'a>","synthetic":false,"types":[]},{"text":"impl<'a> Debug for VariantAst<'a>","synthetic":false,"types":[]},{"text":"impl<'a> Debug for VariantInfo<'a>","synthetic":false,"types":[]},{"text":"impl<'a> Debug for Structure<'a>","synthetic":false,"types":[]}]; +implementors["delog"] = [{"text":"impl<T: ?Sized, S, U> Debug for HexStr<'_, T, U, S> where
    T: AsRef<[u8]>,
    U: Unsigned,
    S: Separator, ","synthetic":false,"types":["delog::hex::HexStr"]},{"text":"impl Debug for Statistics","synthetic":false,"types":["delog::logger::Statistics"]}]; +implementors["flexiber"] = [{"text":"impl<'a> Debug for Decoder<'a>","synthetic":false,"types":["flexiber::decoder::Decoder"]},{"text":"impl<'a> Debug for Encoder<'a>","synthetic":false,"types":["flexiber::encoder::Encoder"]},{"text":"impl Debug for Error","synthetic":false,"types":["flexiber::error::Error"]},{"text":"impl Debug for ErrorKind","synthetic":false,"types":["flexiber::error::ErrorKind"]},{"text":"impl Debug for Length","synthetic":false,"types":["flexiber::length::Length"]},{"text":"impl<'a> Debug for Slice<'a>","synthetic":false,"types":["flexiber::slice::Slice"]},{"text":"impl Debug for Class","synthetic":false,"types":["flexiber::tag::Class"]},{"text":"impl Debug for Tag","synthetic":false,"types":["flexiber::tag::Tag"]},{"text":"impl<V: Debug, T: Debug> Debug for TaggedValue<V, T>","synthetic":false,"types":["flexiber::tagged::TaggedValue"]}]; +implementors["log"] = [{"text":"impl Debug for Level","synthetic":false,"types":["log::Level"]},{"text":"impl Debug for LevelFilter","synthetic":false,"types":["log::LevelFilter"]},{"text":"impl<'a> Debug for Record<'a>","synthetic":false,"types":["log::Record"]},{"text":"impl<'a> Debug for RecordBuilder<'a>","synthetic":false,"types":["log::RecordBuilder"]},{"text":"impl<'a> Debug for Metadata<'a>","synthetic":false,"types":["log::Metadata"]},{"text":"impl<'a> Debug for MetadataBuilder<'a>","synthetic":false,"types":["log::MetadataBuilder"]},{"text":"impl Debug for SetLoggerError","synthetic":false,"types":["log::SetLoggerError"]},{"text":"impl Debug for ParseLevelError","synthetic":false,"types":["log::ParseLevelError"]}]; +implementors["proc_macro2"] = [{"text":"impl Debug for TokenStream","synthetic":false,"types":["proc_macro2::TokenStream"]},{"text":"impl Debug for LexError","synthetic":false,"types":["proc_macro2::LexError"]},{"text":"impl Debug for Span","synthetic":false,"types":["proc_macro2::Span"]},{"text":"impl Debug for TokenTree","synthetic":false,"types":["proc_macro2::TokenTree"]},{"text":"impl Debug for Delimiter","synthetic":false,"types":["proc_macro2::Delimiter"]},{"text":"impl Debug for Group","synthetic":false,"types":["proc_macro2::Group"]},{"text":"impl Debug for Spacing","synthetic":false,"types":["proc_macro2::Spacing"]},{"text":"impl Debug for Punct","synthetic":false,"types":["proc_macro2::Punct"]},{"text":"impl Debug for Ident","synthetic":false,"types":["proc_macro2::Ident"]},{"text":"impl Debug for Literal","synthetic":false,"types":["proc_macro2::Literal"]},{"text":"impl Debug for IntoIter","synthetic":false,"types":["proc_macro2::token_stream::IntoIter"]}]; +implementors["syn"] = [{"text":"impl Debug for Underscore","synthetic":false,"types":["syn::token::Underscore"]},{"text":"impl Debug for Abstract","synthetic":false,"types":["syn::token::Abstract"]},{"text":"impl Debug for As","synthetic":false,"types":["syn::token::As"]},{"text":"impl Debug for Async","synthetic":false,"types":["syn::token::Async"]},{"text":"impl Debug for Auto","synthetic":false,"types":["syn::token::Auto"]},{"text":"impl Debug for Await","synthetic":false,"types":["syn::token::Await"]},{"text":"impl Debug for Become","synthetic":false,"types":["syn::token::Become"]},{"text":"impl Debug for Box","synthetic":false,"types":["syn::token::Box"]},{"text":"impl Debug for Break","synthetic":false,"types":["syn::token::Break"]},{"text":"impl Debug for Const","synthetic":false,"types":["syn::token::Const"]},{"text":"impl Debug for Continue","synthetic":false,"types":["syn::token::Continue"]},{"text":"impl Debug for Crate","synthetic":false,"types":["syn::token::Crate"]},{"text":"impl Debug for Default","synthetic":false,"types":["syn::token::Default"]},{"text":"impl Debug for Do","synthetic":false,"types":["syn::token::Do"]},{"text":"impl Debug for Dyn","synthetic":false,"types":["syn::token::Dyn"]},{"text":"impl Debug for Else","synthetic":false,"types":["syn::token::Else"]},{"text":"impl Debug for Enum","synthetic":false,"types":["syn::token::Enum"]},{"text":"impl Debug for Extern","synthetic":false,"types":["syn::token::Extern"]},{"text":"impl Debug for Final","synthetic":false,"types":["syn::token::Final"]},{"text":"impl Debug for Fn","synthetic":false,"types":["syn::token::Fn"]},{"text":"impl Debug for For","synthetic":false,"types":["syn::token::For"]},{"text":"impl Debug for If","synthetic":false,"types":["syn::token::If"]},{"text":"impl Debug for Impl","synthetic":false,"types":["syn::token::Impl"]},{"text":"impl Debug for In","synthetic":false,"types":["syn::token::In"]},{"text":"impl Debug for Let","synthetic":false,"types":["syn::token::Let"]},{"text":"impl Debug for Loop","synthetic":false,"types":["syn::token::Loop"]},{"text":"impl Debug for Macro","synthetic":false,"types":["syn::token::Macro"]},{"text":"impl Debug for Match","synthetic":false,"types":["syn::token::Match"]},{"text":"impl Debug for Mod","synthetic":false,"types":["syn::token::Mod"]},{"text":"impl Debug for Move","synthetic":false,"types":["syn::token::Move"]},{"text":"impl Debug for Mut","synthetic":false,"types":["syn::token::Mut"]},{"text":"impl Debug for Override","synthetic":false,"types":["syn::token::Override"]},{"text":"impl Debug for Priv","synthetic":false,"types":["syn::token::Priv"]},{"text":"impl Debug for Pub","synthetic":false,"types":["syn::token::Pub"]},{"text":"impl Debug for Ref","synthetic":false,"types":["syn::token::Ref"]},{"text":"impl Debug for Return","synthetic":false,"types":["syn::token::Return"]},{"text":"impl Debug for SelfType","synthetic":false,"types":["syn::token::SelfType"]},{"text":"impl Debug for SelfValue","synthetic":false,"types":["syn::token::SelfValue"]},{"text":"impl Debug for Static","synthetic":false,"types":["syn::token::Static"]},{"text":"impl Debug for Struct","synthetic":false,"types":["syn::token::Struct"]},{"text":"impl Debug for Super","synthetic":false,"types":["syn::token::Super"]},{"text":"impl Debug for Trait","synthetic":false,"types":["syn::token::Trait"]},{"text":"impl Debug for Try","synthetic":false,"types":["syn::token::Try"]},{"text":"impl Debug for Type","synthetic":false,"types":["syn::token::Type"]},{"text":"impl Debug for Typeof","synthetic":false,"types":["syn::token::Typeof"]},{"text":"impl Debug for Union","synthetic":false,"types":["syn::token::Union"]},{"text":"impl Debug for Unsafe","synthetic":false,"types":["syn::token::Unsafe"]},{"text":"impl Debug for Unsized","synthetic":false,"types":["syn::token::Unsized"]},{"text":"impl Debug for Use","synthetic":false,"types":["syn::token::Use"]},{"text":"impl Debug for Virtual","synthetic":false,"types":["syn::token::Virtual"]},{"text":"impl Debug for Where","synthetic":false,"types":["syn::token::Where"]},{"text":"impl Debug for While","synthetic":false,"types":["syn::token::While"]},{"text":"impl Debug for Yield","synthetic":false,"types":["syn::token::Yield"]},{"text":"impl Debug for Add","synthetic":false,"types":["syn::token::Add"]},{"text":"impl Debug for AddEq","synthetic":false,"types":["syn::token::AddEq"]},{"text":"impl Debug for And","synthetic":false,"types":["syn::token::And"]},{"text":"impl Debug for AndAnd","synthetic":false,"types":["syn::token::AndAnd"]},{"text":"impl Debug for AndEq","synthetic":false,"types":["syn::token::AndEq"]},{"text":"impl Debug for At","synthetic":false,"types":["syn::token::At"]},{"text":"impl Debug for Bang","synthetic":false,"types":["syn::token::Bang"]},{"text":"impl Debug for Caret","synthetic":false,"types":["syn::token::Caret"]},{"text":"impl Debug for CaretEq","synthetic":false,"types":["syn::token::CaretEq"]},{"text":"impl Debug for Colon","synthetic":false,"types":["syn::token::Colon"]},{"text":"impl Debug for Colon2","synthetic":false,"types":["syn::token::Colon2"]},{"text":"impl Debug for Comma","synthetic":false,"types":["syn::token::Comma"]},{"text":"impl Debug for Div","synthetic":false,"types":["syn::token::Div"]},{"text":"impl Debug for DivEq","synthetic":false,"types":["syn::token::DivEq"]},{"text":"impl Debug for Dollar","synthetic":false,"types":["syn::token::Dollar"]},{"text":"impl Debug for Dot","synthetic":false,"types":["syn::token::Dot"]},{"text":"impl Debug for Dot2","synthetic":false,"types":["syn::token::Dot2"]},{"text":"impl Debug for Dot3","synthetic":false,"types":["syn::token::Dot3"]},{"text":"impl Debug for DotDotEq","synthetic":false,"types":["syn::token::DotDotEq"]},{"text":"impl Debug for Eq","synthetic":false,"types":["syn::token::Eq"]},{"text":"impl Debug for EqEq","synthetic":false,"types":["syn::token::EqEq"]},{"text":"impl Debug for Ge","synthetic":false,"types":["syn::token::Ge"]},{"text":"impl Debug for Gt","synthetic":false,"types":["syn::token::Gt"]},{"text":"impl Debug for Le","synthetic":false,"types":["syn::token::Le"]},{"text":"impl Debug for Lt","synthetic":false,"types":["syn::token::Lt"]},{"text":"impl Debug for MulEq","synthetic":false,"types":["syn::token::MulEq"]},{"text":"impl Debug for Ne","synthetic":false,"types":["syn::token::Ne"]},{"text":"impl Debug for Or","synthetic":false,"types":["syn::token::Or"]},{"text":"impl Debug for OrEq","synthetic":false,"types":["syn::token::OrEq"]},{"text":"impl Debug for OrOr","synthetic":false,"types":["syn::token::OrOr"]},{"text":"impl Debug for Pound","synthetic":false,"types":["syn::token::Pound"]},{"text":"impl Debug for Question","synthetic":false,"types":["syn::token::Question"]},{"text":"impl Debug for RArrow","synthetic":false,"types":["syn::token::RArrow"]},{"text":"impl Debug for LArrow","synthetic":false,"types":["syn::token::LArrow"]},{"text":"impl Debug for Rem","synthetic":false,"types":["syn::token::Rem"]},{"text":"impl Debug for RemEq","synthetic":false,"types":["syn::token::RemEq"]},{"text":"impl Debug for FatArrow","synthetic":false,"types":["syn::token::FatArrow"]},{"text":"impl Debug for Semi","synthetic":false,"types":["syn::token::Semi"]},{"text":"impl Debug for Shl","synthetic":false,"types":["syn::token::Shl"]},{"text":"impl Debug for ShlEq","synthetic":false,"types":["syn::token::ShlEq"]},{"text":"impl Debug for Shr","synthetic":false,"types":["syn::token::Shr"]},{"text":"impl Debug for ShrEq","synthetic":false,"types":["syn::token::ShrEq"]},{"text":"impl Debug for Star","synthetic":false,"types":["syn::token::Star"]},{"text":"impl Debug for Sub","synthetic":false,"types":["syn::token::Sub"]},{"text":"impl Debug for SubEq","synthetic":false,"types":["syn::token::SubEq"]},{"text":"impl Debug for Tilde","synthetic":false,"types":["syn::token::Tilde"]},{"text":"impl Debug for Brace","synthetic":false,"types":["syn::token::Brace"]},{"text":"impl Debug for Bracket","synthetic":false,"types":["syn::token::Bracket"]},{"text":"impl Debug for Paren","synthetic":false,"types":["syn::token::Paren"]},{"text":"impl Debug for Group","synthetic":false,"types":["syn::token::Group"]},{"text":"impl<'a> Debug for ImplGenerics<'a>","synthetic":false,"types":["syn::generics::ImplGenerics"]},{"text":"impl<'a> Debug for TypeGenerics<'a>","synthetic":false,"types":["syn::generics::TypeGenerics"]},{"text":"impl<'a> Debug for Turbofish<'a>","synthetic":false,"types":["syn::generics::Turbofish"]},{"text":"impl Debug for LitStr","synthetic":false,"types":["syn::lit::LitStr"]},{"text":"impl Debug for LitByteStr","synthetic":false,"types":["syn::lit::LitByteStr"]},{"text":"impl Debug for LitByte","synthetic":false,"types":["syn::lit::LitByte"]},{"text":"impl Debug for LitChar","synthetic":false,"types":["syn::lit::LitChar"]},{"text":"impl Debug for LitInt","synthetic":false,"types":["syn::lit::LitInt"]},{"text":"impl Debug for LitFloat","synthetic":false,"types":["syn::lit::LitFloat"]},{"text":"impl Debug for LitBool","synthetic":false,"types":["syn::lit::LitBool"]},{"text":"impl<T: Debug, P: Debug> Debug for Punctuated<T, P>","synthetic":false,"types":["syn::punctuated::Punctuated"]},{"text":"impl Debug for Abi","synthetic":false,"types":["syn::ty::Abi"]},{"text":"impl Debug for AngleBracketedGenericArguments","synthetic":false,"types":["syn::path::AngleBracketedGenericArguments"]},{"text":"impl Debug for AttrStyle","synthetic":false,"types":["syn::attr::AttrStyle"]},{"text":"impl Debug for Attribute","synthetic":false,"types":["syn::attr::Attribute"]},{"text":"impl Debug for BareFnArg","synthetic":false,"types":["syn::ty::BareFnArg"]},{"text":"impl Debug for BinOp","synthetic":false,"types":["syn::op::BinOp"]},{"text":"impl Debug for Binding","synthetic":false,"types":["syn::path::Binding"]},{"text":"impl Debug for BoundLifetimes","synthetic":false,"types":["syn::generics::BoundLifetimes"]},{"text":"impl Debug for ConstParam","synthetic":false,"types":["syn::generics::ConstParam"]},{"text":"impl Debug for Constraint","synthetic":false,"types":["syn::path::Constraint"]},{"text":"impl Debug for Data","synthetic":false,"types":["syn::derive::Data"]},{"text":"impl Debug for DataEnum","synthetic":false,"types":["syn::derive::DataEnum"]},{"text":"impl Debug for DataStruct","synthetic":false,"types":["syn::derive::DataStruct"]},{"text":"impl Debug for DataUnion","synthetic":false,"types":["syn::derive::DataUnion"]},{"text":"impl Debug for DeriveInput","synthetic":false,"types":["syn::derive::DeriveInput"]},{"text":"impl Debug for Expr","synthetic":false,"types":["syn::expr::Expr"]},{"text":"impl Debug for ExprBinary","synthetic":false,"types":["syn::expr::ExprBinary"]},{"text":"impl Debug for ExprCall","synthetic":false,"types":["syn::expr::ExprCall"]},{"text":"impl Debug for ExprCast","synthetic":false,"types":["syn::expr::ExprCast"]},{"text":"impl Debug for ExprField","synthetic":false,"types":["syn::expr::ExprField"]},{"text":"impl Debug for ExprIndex","synthetic":false,"types":["syn::expr::ExprIndex"]},{"text":"impl Debug for ExprLit","synthetic":false,"types":["syn::expr::ExprLit"]},{"text":"impl Debug for ExprParen","synthetic":false,"types":["syn::expr::ExprParen"]},{"text":"impl Debug for ExprPath","synthetic":false,"types":["syn::expr::ExprPath"]},{"text":"impl Debug for ExprUnary","synthetic":false,"types":["syn::expr::ExprUnary"]},{"text":"impl Debug for Field","synthetic":false,"types":["syn::data::Field"]},{"text":"impl Debug for Fields","synthetic":false,"types":["syn::data::Fields"]},{"text":"impl Debug for FieldsNamed","synthetic":false,"types":["syn::data::FieldsNamed"]},{"text":"impl Debug for FieldsUnnamed","synthetic":false,"types":["syn::data::FieldsUnnamed"]},{"text":"impl Debug for GenericArgument","synthetic":false,"types":["syn::path::GenericArgument"]},{"text":"impl Debug for GenericParam","synthetic":false,"types":["syn::generics::GenericParam"]},{"text":"impl Debug for Generics","synthetic":false,"types":["syn::generics::Generics"]},{"text":"impl Debug for Index","synthetic":false,"types":["syn::expr::Index"]},{"text":"impl Debug for Lifetime","synthetic":false,"types":["syn::lifetime::Lifetime"]},{"text":"impl Debug for LifetimeDef","synthetic":false,"types":["syn::generics::LifetimeDef"]},{"text":"impl Debug for Lit","synthetic":false,"types":["syn::lit::Lit"]},{"text":"impl Debug for Macro","synthetic":false,"types":["syn::mac::Macro"]},{"text":"impl Debug for MacroDelimiter","synthetic":false,"types":["syn::mac::MacroDelimiter"]},{"text":"impl Debug for Member","synthetic":false,"types":["syn::expr::Member"]},{"text":"impl Debug for Meta","synthetic":false,"types":["syn::attr::Meta"]},{"text":"impl Debug for MetaList","synthetic":false,"types":["syn::attr::MetaList"]},{"text":"impl Debug for MetaNameValue","synthetic":false,"types":["syn::attr::MetaNameValue"]},{"text":"impl Debug for NestedMeta","synthetic":false,"types":["syn::attr::NestedMeta"]},{"text":"impl Debug for ParenthesizedGenericArguments","synthetic":false,"types":["syn::path::ParenthesizedGenericArguments"]},{"text":"impl Debug for Path","synthetic":false,"types":["syn::path::Path"]},{"text":"impl Debug for PathArguments","synthetic":false,"types":["syn::path::PathArguments"]},{"text":"impl Debug for PathSegment","synthetic":false,"types":["syn::path::PathSegment"]},{"text":"impl Debug for PredicateEq","synthetic":false,"types":["syn::generics::PredicateEq"]},{"text":"impl Debug for PredicateLifetime","synthetic":false,"types":["syn::generics::PredicateLifetime"]},{"text":"impl Debug for PredicateType","synthetic":false,"types":["syn::generics::PredicateType"]},{"text":"impl Debug for QSelf","synthetic":false,"types":["syn::path::QSelf"]},{"text":"impl Debug for ReturnType","synthetic":false,"types":["syn::ty::ReturnType"]},{"text":"impl Debug for TraitBound","synthetic":false,"types":["syn::generics::TraitBound"]},{"text":"impl Debug for TraitBoundModifier","synthetic":false,"types":["syn::generics::TraitBoundModifier"]},{"text":"impl Debug for Type","synthetic":false,"types":["syn::ty::Type"]},{"text":"impl Debug for TypeArray","synthetic":false,"types":["syn::ty::TypeArray"]},{"text":"impl Debug for TypeBareFn","synthetic":false,"types":["syn::ty::TypeBareFn"]},{"text":"impl Debug for TypeGroup","synthetic":false,"types":["syn::ty::TypeGroup"]},{"text":"impl Debug for TypeImplTrait","synthetic":false,"types":["syn::ty::TypeImplTrait"]},{"text":"impl Debug for TypeInfer","synthetic":false,"types":["syn::ty::TypeInfer"]},{"text":"impl Debug for TypeMacro","synthetic":false,"types":["syn::ty::TypeMacro"]},{"text":"impl Debug for TypeNever","synthetic":false,"types":["syn::ty::TypeNever"]},{"text":"impl Debug for TypeParam","synthetic":false,"types":["syn::generics::TypeParam"]},{"text":"impl Debug for TypeParamBound","synthetic":false,"types":["syn::generics::TypeParamBound"]},{"text":"impl Debug for TypeParen","synthetic":false,"types":["syn::ty::TypeParen"]},{"text":"impl Debug for TypePath","synthetic":false,"types":["syn::ty::TypePath"]},{"text":"impl Debug for TypePtr","synthetic":false,"types":["syn::ty::TypePtr"]},{"text":"impl Debug for TypeReference","synthetic":false,"types":["syn::ty::TypeReference"]},{"text":"impl Debug for TypeSlice","synthetic":false,"types":["syn::ty::TypeSlice"]},{"text":"impl Debug for TypeTraitObject","synthetic":false,"types":["syn::ty::TypeTraitObject"]},{"text":"impl Debug for TypeTuple","synthetic":false,"types":["syn::ty::TypeTuple"]},{"text":"impl Debug for UnOp","synthetic":false,"types":["syn::op::UnOp"]},{"text":"impl Debug for Variadic","synthetic":false,"types":["syn::ty::Variadic"]},{"text":"impl Debug for Variant","synthetic":false,"types":["syn::data::Variant"]},{"text":"impl Debug for VisCrate","synthetic":false,"types":["syn::data::VisCrate"]},{"text":"impl Debug for VisPublic","synthetic":false,"types":["syn::data::VisPublic"]},{"text":"impl Debug for VisRestricted","synthetic":false,"types":["syn::data::VisRestricted"]},{"text":"impl Debug for Visibility","synthetic":false,"types":["syn::data::Visibility"]},{"text":"impl Debug for WhereClause","synthetic":false,"types":["syn::generics::WhereClause"]},{"text":"impl Debug for WherePredicate","synthetic":false,"types":["syn::generics::WherePredicate"]},{"text":"impl<'a> Debug for ParseBuffer<'a>","synthetic":false,"types":["syn::parse::ParseBuffer"]},{"text":"impl Debug for Error","synthetic":false,"types":["syn::error::Error"]}]; +implementors["synstructure"] = [{"text":"impl Debug for AddBounds","synthetic":false,"types":["synstructure::AddBounds"]},{"text":"impl Debug for BindStyle","synthetic":false,"types":["synstructure::BindStyle"]},{"text":"impl<'a> Debug for BindingInfo<'a>","synthetic":false,"types":["synstructure::BindingInfo"]},{"text":"impl<'a> Debug for VariantAst<'a>","synthetic":false,"types":["synstructure::VariantAst"]},{"text":"impl<'a> Debug for VariantInfo<'a>","synthetic":false,"types":["synstructure::VariantInfo"]},{"text":"impl<'a> Debug for Structure<'a>","synthetic":false,"types":["synstructure::Structure"]}]; if (window.register_implementors) {window.register_implementors(implementors);} else {window.pending_implementors = implementors;}})() \ No newline at end of file diff --git a/implementors/core/fmt/trait.Display.js b/implementors/core/fmt/trait.Display.js index 4cfac4a..46bda33 100644 --- a/implementors/core/fmt/trait.Display.js +++ b/implementors/core/fmt/trait.Display.js @@ -1,7 +1,7 @@ (function() {var implementors = {}; -implementors["delog"] = [{"text":"impl<T: ?Sized, U, S> Display for HexStr<'_, T, U, S> where
    T: AsRef<[u8]>,
    U: Unsigned,
    S: Separator, ","synthetic":false,"types":[]}]; -implementors["flexiber"] = [{"text":"impl Display for Error","synthetic":false,"types":[]},{"text":"impl Display for ErrorKind","synthetic":false,"types":[]},{"text":"impl Display for Length","synthetic":false,"types":[]},{"text":"impl Display for Tag","synthetic":false,"types":[]}]; -implementors["log"] = [{"text":"impl Display for Level","synthetic":false,"types":[]},{"text":"impl Display for LevelFilter","synthetic":false,"types":[]},{"text":"impl Display for SetLoggerError","synthetic":false,"types":[]},{"text":"impl Display for ParseLevelError","synthetic":false,"types":[]}]; -implementors["proc_macro2"] = [{"text":"impl Display for TokenStream","synthetic":false,"types":[]},{"text":"impl Display for LexError","synthetic":false,"types":[]},{"text":"impl Display for TokenTree","synthetic":false,"types":[]},{"text":"impl Display for Group","synthetic":false,"types":[]},{"text":"impl Display for Punct","synthetic":false,"types":[]},{"text":"impl Display for Ident","synthetic":false,"types":[]},{"text":"impl Display for Literal","synthetic":false,"types":[]}]; -implementors["syn"] = [{"text":"impl Display for Lifetime","synthetic":false,"types":[]},{"text":"impl Display for LitInt","synthetic":false,"types":[]},{"text":"impl Display for LitFloat","synthetic":false,"types":[]},{"text":"impl<'a> Display for ParseBuffer<'a>","synthetic":false,"types":[]},{"text":"impl Display for Error","synthetic":false,"types":[]}]; +implementors["delog"] = [{"text":"impl<T: ?Sized, U, S> Display for HexStr<'_, T, U, S> where
    T: AsRef<[u8]>,
    U: Unsigned,
    S: Separator, ","synthetic":false,"types":["delog::hex::HexStr"]}]; +implementors["flexiber"] = [{"text":"impl Display for Error","synthetic":false,"types":["flexiber::error::Error"]},{"text":"impl Display for ErrorKind","synthetic":false,"types":["flexiber::error::ErrorKind"]},{"text":"impl Display for Length","synthetic":false,"types":["flexiber::length::Length"]},{"text":"impl Display for Tag","synthetic":false,"types":["flexiber::tag::Tag"]}]; +implementors["log"] = [{"text":"impl Display for Level","synthetic":false,"types":["log::Level"]},{"text":"impl Display for LevelFilter","synthetic":false,"types":["log::LevelFilter"]},{"text":"impl Display for SetLoggerError","synthetic":false,"types":["log::SetLoggerError"]},{"text":"impl Display for ParseLevelError","synthetic":false,"types":["log::ParseLevelError"]}]; +implementors["proc_macro2"] = [{"text":"impl Display for TokenStream","synthetic":false,"types":["proc_macro2::TokenStream"]},{"text":"impl Display for LexError","synthetic":false,"types":["proc_macro2::LexError"]},{"text":"impl Display for TokenTree","synthetic":false,"types":["proc_macro2::TokenTree"]},{"text":"impl Display for Group","synthetic":false,"types":["proc_macro2::Group"]},{"text":"impl Display for Punct","synthetic":false,"types":["proc_macro2::Punct"]},{"text":"impl Display for Ident","synthetic":false,"types":["proc_macro2::Ident"]},{"text":"impl Display for Literal","synthetic":false,"types":["proc_macro2::Literal"]}]; +implementors["syn"] = [{"text":"impl Display for Lifetime","synthetic":false,"types":["syn::lifetime::Lifetime"]},{"text":"impl Display for LitInt","synthetic":false,"types":["syn::lit::LitInt"]},{"text":"impl Display for LitFloat","synthetic":false,"types":["syn::lit::LitFloat"]},{"text":"impl<'a> Display for ParseBuffer<'a>","synthetic":false,"types":["syn::parse::ParseBuffer"]},{"text":"impl Display for Error","synthetic":false,"types":["syn::error::Error"]}]; if (window.register_implementors) {window.register_implementors(implementors);} else {window.pending_implementors = implementors;}})() \ No newline at end of file diff --git a/implementors/core/fmt/trait.LowerHex.js b/implementors/core/fmt/trait.LowerHex.js index 42edf5e..381d35d 100644 --- a/implementors/core/fmt/trait.LowerHex.js +++ b/implementors/core/fmt/trait.LowerHex.js @@ -1,3 +1,3 @@ (function() {var implementors = {}; -implementors["delog"] = [{"text":"impl<'a, T: ?Sized, U, S> LowerHex for HexStr<'a, T, U, S> where
    T: AsRef<[u8]>,
    U: Unsigned,
    S: Separator, ","synthetic":false,"types":[]}]; +implementors["delog"] = [{"text":"impl<'a, T: ?Sized, U, S> LowerHex for HexStr<'a, T, U, S> where
    T: AsRef<[u8]>,
    U: Unsigned,
    S: Separator, ","synthetic":false,"types":["delog::hex::HexStr"]}]; if (window.register_implementors) {window.register_implementors(implementors);} else {window.pending_implementors = implementors;}})() \ No newline at end of file diff --git a/implementors/core/fmt/trait.UpperHex.js b/implementors/core/fmt/trait.UpperHex.js index 969007c..2cba9ea 100644 --- a/implementors/core/fmt/trait.UpperHex.js +++ b/implementors/core/fmt/trait.UpperHex.js @@ -1,3 +1,3 @@ (function() {var implementors = {}; -implementors["delog"] = [{"text":"impl<'a, T: ?Sized, U, S> UpperHex for HexStr<'a, T, U, S> where
    T: AsRef<[u8]>,
    U: Unsigned,
    S: Separator, ","synthetic":false,"types":[]}]; +implementors["delog"] = [{"text":"impl<'a, T: ?Sized, U, S> UpperHex for HexStr<'a, T, U, S> where
    T: AsRef<[u8]>,
    U: Unsigned,
    S: Separator, ","synthetic":false,"types":["delog::hex::HexStr"]}]; if (window.register_implementors) {window.register_implementors(implementors);} else {window.pending_implementors = implementors;}})() \ No newline at end of file diff --git a/implementors/core/hash/trait.Hash.js b/implementors/core/hash/trait.Hash.js index bdc4532..56fd6b2 100644 --- a/implementors/core/hash/trait.Hash.js +++ b/implementors/core/hash/trait.Hash.js @@ -1,6 +1,6 @@ (function() {var implementors = {}; -implementors["log"] = [{"text":"impl Hash for Level","synthetic":false,"types":[]},{"text":"impl Hash for LevelFilter","synthetic":false,"types":[]},{"text":"impl<'a> Hash for Metadata<'a>","synthetic":false,"types":[]},{"text":"impl<'a> Hash for MetadataBuilder<'a>","synthetic":false,"types":[]}]; -implementors["proc_macro2"] = [{"text":"impl Hash for Ident","synthetic":false,"types":[]}]; -implementors["syn"] = [{"text":"impl Hash for Underscore","synthetic":false,"types":[]},{"text":"impl Hash for Abstract","synthetic":false,"types":[]},{"text":"impl Hash for As","synthetic":false,"types":[]},{"text":"impl Hash for Async","synthetic":false,"types":[]},{"text":"impl Hash for Auto","synthetic":false,"types":[]},{"text":"impl Hash for Await","synthetic":false,"types":[]},{"text":"impl Hash for Become","synthetic":false,"types":[]},{"text":"impl Hash for Box","synthetic":false,"types":[]},{"text":"impl Hash for Break","synthetic":false,"types":[]},{"text":"impl Hash for Const","synthetic":false,"types":[]},{"text":"impl Hash for Continue","synthetic":false,"types":[]},{"text":"impl Hash for Crate","synthetic":false,"types":[]},{"text":"impl Hash for Default","synthetic":false,"types":[]},{"text":"impl Hash for Do","synthetic":false,"types":[]},{"text":"impl Hash for Dyn","synthetic":false,"types":[]},{"text":"impl Hash for Else","synthetic":false,"types":[]},{"text":"impl Hash for Enum","synthetic":false,"types":[]},{"text":"impl Hash for Extern","synthetic":false,"types":[]},{"text":"impl Hash for Final","synthetic":false,"types":[]},{"text":"impl Hash for Fn","synthetic":false,"types":[]},{"text":"impl Hash for For","synthetic":false,"types":[]},{"text":"impl Hash for If","synthetic":false,"types":[]},{"text":"impl Hash for Impl","synthetic":false,"types":[]},{"text":"impl Hash for In","synthetic":false,"types":[]},{"text":"impl Hash for Let","synthetic":false,"types":[]},{"text":"impl Hash for Loop","synthetic":false,"types":[]},{"text":"impl Hash for Macro","synthetic":false,"types":[]},{"text":"impl Hash for Match","synthetic":false,"types":[]},{"text":"impl Hash for Mod","synthetic":false,"types":[]},{"text":"impl Hash for Move","synthetic":false,"types":[]},{"text":"impl Hash for Mut","synthetic":false,"types":[]},{"text":"impl Hash for Override","synthetic":false,"types":[]},{"text":"impl Hash for Priv","synthetic":false,"types":[]},{"text":"impl Hash for Pub","synthetic":false,"types":[]},{"text":"impl Hash for Ref","synthetic":false,"types":[]},{"text":"impl Hash for Return","synthetic":false,"types":[]},{"text":"impl Hash for SelfType","synthetic":false,"types":[]},{"text":"impl Hash for SelfValue","synthetic":false,"types":[]},{"text":"impl Hash for Static","synthetic":false,"types":[]},{"text":"impl Hash for Struct","synthetic":false,"types":[]},{"text":"impl Hash for Super","synthetic":false,"types":[]},{"text":"impl Hash for Trait","synthetic":false,"types":[]},{"text":"impl Hash for Try","synthetic":false,"types":[]},{"text":"impl Hash for Type","synthetic":false,"types":[]},{"text":"impl Hash for Typeof","synthetic":false,"types":[]},{"text":"impl Hash for Union","synthetic":false,"types":[]},{"text":"impl Hash for Unsafe","synthetic":false,"types":[]},{"text":"impl Hash for Unsized","synthetic":false,"types":[]},{"text":"impl Hash for Use","synthetic":false,"types":[]},{"text":"impl Hash for Virtual","synthetic":false,"types":[]},{"text":"impl Hash for Where","synthetic":false,"types":[]},{"text":"impl Hash for While","synthetic":false,"types":[]},{"text":"impl Hash for Yield","synthetic":false,"types":[]},{"text":"impl Hash for Add","synthetic":false,"types":[]},{"text":"impl Hash for AddEq","synthetic":false,"types":[]},{"text":"impl Hash for And","synthetic":false,"types":[]},{"text":"impl Hash for AndAnd","synthetic":false,"types":[]},{"text":"impl Hash for AndEq","synthetic":false,"types":[]},{"text":"impl Hash for At","synthetic":false,"types":[]},{"text":"impl Hash for Bang","synthetic":false,"types":[]},{"text":"impl Hash for Caret","synthetic":false,"types":[]},{"text":"impl Hash for CaretEq","synthetic":false,"types":[]},{"text":"impl Hash for Colon","synthetic":false,"types":[]},{"text":"impl Hash for Colon2","synthetic":false,"types":[]},{"text":"impl Hash for Comma","synthetic":false,"types":[]},{"text":"impl Hash for Div","synthetic":false,"types":[]},{"text":"impl Hash for DivEq","synthetic":false,"types":[]},{"text":"impl Hash for Dollar","synthetic":false,"types":[]},{"text":"impl Hash for Dot","synthetic":false,"types":[]},{"text":"impl Hash for Dot2","synthetic":false,"types":[]},{"text":"impl Hash for Dot3","synthetic":false,"types":[]},{"text":"impl Hash for DotDotEq","synthetic":false,"types":[]},{"text":"impl Hash for Eq","synthetic":false,"types":[]},{"text":"impl Hash for EqEq","synthetic":false,"types":[]},{"text":"impl Hash for Ge","synthetic":false,"types":[]},{"text":"impl Hash for Gt","synthetic":false,"types":[]},{"text":"impl Hash for Le","synthetic":false,"types":[]},{"text":"impl Hash for Lt","synthetic":false,"types":[]},{"text":"impl Hash for MulEq","synthetic":false,"types":[]},{"text":"impl Hash for Ne","synthetic":false,"types":[]},{"text":"impl Hash for Or","synthetic":false,"types":[]},{"text":"impl Hash for OrEq","synthetic":false,"types":[]},{"text":"impl Hash for OrOr","synthetic":false,"types":[]},{"text":"impl Hash for Pound","synthetic":false,"types":[]},{"text":"impl Hash for Question","synthetic":false,"types":[]},{"text":"impl Hash for RArrow","synthetic":false,"types":[]},{"text":"impl Hash for LArrow","synthetic":false,"types":[]},{"text":"impl Hash for Rem","synthetic":false,"types":[]},{"text":"impl Hash for RemEq","synthetic":false,"types":[]},{"text":"impl Hash for FatArrow","synthetic":false,"types":[]},{"text":"impl Hash for Semi","synthetic":false,"types":[]},{"text":"impl Hash for Shl","synthetic":false,"types":[]},{"text":"impl Hash for ShlEq","synthetic":false,"types":[]},{"text":"impl Hash for Shr","synthetic":false,"types":[]},{"text":"impl Hash for ShrEq","synthetic":false,"types":[]},{"text":"impl Hash for Star","synthetic":false,"types":[]},{"text":"impl Hash for Sub","synthetic":false,"types":[]},{"text":"impl Hash for SubEq","synthetic":false,"types":[]},{"text":"impl Hash for Tilde","synthetic":false,"types":[]},{"text":"impl Hash for Brace","synthetic":false,"types":[]},{"text":"impl Hash for Bracket","synthetic":false,"types":[]},{"text":"impl Hash for Paren","synthetic":false,"types":[]},{"text":"impl Hash for Group","synthetic":false,"types":[]},{"text":"impl Hash for Member","synthetic":false,"types":[]},{"text":"impl Hash for Index","synthetic":false,"types":[]},{"text":"impl<'a> Hash for ImplGenerics<'a>","synthetic":false,"types":[]},{"text":"impl<'a> Hash for TypeGenerics<'a>","synthetic":false,"types":[]},{"text":"impl<'a> Hash for Turbofish<'a>","synthetic":false,"types":[]},{"text":"impl Hash for Lifetime","synthetic":false,"types":[]},{"text":"impl Hash for LitStr","synthetic":false,"types":[]},{"text":"impl Hash for LitByteStr","synthetic":false,"types":[]},{"text":"impl Hash for LitByte","synthetic":false,"types":[]},{"text":"impl Hash for LitChar","synthetic":false,"types":[]},{"text":"impl Hash for LitInt","synthetic":false,"types":[]},{"text":"impl Hash for LitFloat","synthetic":false,"types":[]},{"text":"impl<T, P> Hash for Punctuated<T, P> where
    T: Hash,
    P: Hash, ","synthetic":false,"types":[]},{"text":"impl Hash for Abi","synthetic":false,"types":[]},{"text":"impl Hash for AngleBracketedGenericArguments","synthetic":false,"types":[]},{"text":"impl Hash for AttrStyle","synthetic":false,"types":[]},{"text":"impl Hash for Attribute","synthetic":false,"types":[]},{"text":"impl Hash for BareFnArg","synthetic":false,"types":[]},{"text":"impl Hash for BinOp","synthetic":false,"types":[]},{"text":"impl Hash for Binding","synthetic":false,"types":[]},{"text":"impl Hash for BoundLifetimes","synthetic":false,"types":[]},{"text":"impl Hash for ConstParam","synthetic":false,"types":[]},{"text":"impl Hash for Constraint","synthetic":false,"types":[]},{"text":"impl Hash for Data","synthetic":false,"types":[]},{"text":"impl Hash for DataEnum","synthetic":false,"types":[]},{"text":"impl Hash for DataStruct","synthetic":false,"types":[]},{"text":"impl Hash for DataUnion","synthetic":false,"types":[]},{"text":"impl Hash for DeriveInput","synthetic":false,"types":[]},{"text":"impl Hash for Expr","synthetic":false,"types":[]},{"text":"impl Hash for ExprBinary","synthetic":false,"types":[]},{"text":"impl Hash for ExprCall","synthetic":false,"types":[]},{"text":"impl Hash for ExprCast","synthetic":false,"types":[]},{"text":"impl Hash for ExprField","synthetic":false,"types":[]},{"text":"impl Hash for ExprIndex","synthetic":false,"types":[]},{"text":"impl Hash for ExprLit","synthetic":false,"types":[]},{"text":"impl Hash for ExprParen","synthetic":false,"types":[]},{"text":"impl Hash for ExprPath","synthetic":false,"types":[]},{"text":"impl Hash for ExprUnary","synthetic":false,"types":[]},{"text":"impl Hash for Field","synthetic":false,"types":[]},{"text":"impl Hash for Fields","synthetic":false,"types":[]},{"text":"impl Hash for FieldsNamed","synthetic":false,"types":[]},{"text":"impl Hash for FieldsUnnamed","synthetic":false,"types":[]},{"text":"impl Hash for GenericArgument","synthetic":false,"types":[]},{"text":"impl Hash for GenericParam","synthetic":false,"types":[]},{"text":"impl Hash for Generics","synthetic":false,"types":[]},{"text":"impl Hash for LifetimeDef","synthetic":false,"types":[]},{"text":"impl Hash for Lit","synthetic":false,"types":[]},{"text":"impl Hash for LitBool","synthetic":false,"types":[]},{"text":"impl Hash for Macro","synthetic":false,"types":[]},{"text":"impl Hash for MacroDelimiter","synthetic":false,"types":[]},{"text":"impl Hash for Meta","synthetic":false,"types":[]},{"text":"impl Hash for MetaList","synthetic":false,"types":[]},{"text":"impl Hash for MetaNameValue","synthetic":false,"types":[]},{"text":"impl Hash for NestedMeta","synthetic":false,"types":[]},{"text":"impl Hash for ParenthesizedGenericArguments","synthetic":false,"types":[]},{"text":"impl Hash for Path","synthetic":false,"types":[]},{"text":"impl Hash for PathArguments","synthetic":false,"types":[]},{"text":"impl Hash for PathSegment","synthetic":false,"types":[]},{"text":"impl Hash for PredicateEq","synthetic":false,"types":[]},{"text":"impl Hash for PredicateLifetime","synthetic":false,"types":[]},{"text":"impl Hash for PredicateType","synthetic":false,"types":[]},{"text":"impl Hash for QSelf","synthetic":false,"types":[]},{"text":"impl Hash for ReturnType","synthetic":false,"types":[]},{"text":"impl Hash for TraitBound","synthetic":false,"types":[]},{"text":"impl Hash for TraitBoundModifier","synthetic":false,"types":[]},{"text":"impl Hash for Type","synthetic":false,"types":[]},{"text":"impl Hash for TypeArray","synthetic":false,"types":[]},{"text":"impl Hash for TypeBareFn","synthetic":false,"types":[]},{"text":"impl Hash for TypeGroup","synthetic":false,"types":[]},{"text":"impl Hash for TypeImplTrait","synthetic":false,"types":[]},{"text":"impl Hash for TypeInfer","synthetic":false,"types":[]},{"text":"impl Hash for TypeMacro","synthetic":false,"types":[]},{"text":"impl Hash for TypeNever","synthetic":false,"types":[]},{"text":"impl Hash for TypeParam","synthetic":false,"types":[]},{"text":"impl Hash for TypeParamBound","synthetic":false,"types":[]},{"text":"impl Hash for TypeParen","synthetic":false,"types":[]},{"text":"impl Hash for TypePath","synthetic":false,"types":[]},{"text":"impl Hash for TypePtr","synthetic":false,"types":[]},{"text":"impl Hash for TypeReference","synthetic":false,"types":[]},{"text":"impl Hash for TypeSlice","synthetic":false,"types":[]},{"text":"impl Hash for TypeTraitObject","synthetic":false,"types":[]},{"text":"impl Hash for TypeTuple","synthetic":false,"types":[]},{"text":"impl Hash for UnOp","synthetic":false,"types":[]},{"text":"impl Hash for Variadic","synthetic":false,"types":[]},{"text":"impl Hash for Variant","synthetic":false,"types":[]},{"text":"impl Hash for VisCrate","synthetic":false,"types":[]},{"text":"impl Hash for VisPublic","synthetic":false,"types":[]},{"text":"impl Hash for VisRestricted","synthetic":false,"types":[]},{"text":"impl Hash for Visibility","synthetic":false,"types":[]},{"text":"impl Hash for WhereClause","synthetic":false,"types":[]},{"text":"impl Hash for WherePredicate","synthetic":false,"types":[]}]; -implementors["synstructure"] = [{"text":"impl Hash for AddBounds","synthetic":false,"types":[]},{"text":"impl Hash for BindStyle","synthetic":false,"types":[]},{"text":"impl<'a> Hash for BindingInfo<'a>","synthetic":false,"types":[]},{"text":"impl<'a> Hash for VariantAst<'a>","synthetic":false,"types":[]},{"text":"impl<'a> Hash for VariantInfo<'a>","synthetic":false,"types":[]},{"text":"impl<'a> Hash for Structure<'a>","synthetic":false,"types":[]}]; +implementors["log"] = [{"text":"impl Hash for Level","synthetic":false,"types":["log::Level"]},{"text":"impl Hash for LevelFilter","synthetic":false,"types":["log::LevelFilter"]},{"text":"impl<'a> Hash for Metadata<'a>","synthetic":false,"types":["log::Metadata"]},{"text":"impl<'a> Hash for MetadataBuilder<'a>","synthetic":false,"types":["log::MetadataBuilder"]}]; +implementors["proc_macro2"] = [{"text":"impl Hash for Ident","synthetic":false,"types":["proc_macro2::Ident"]}]; +implementors["syn"] = [{"text":"impl Hash for Underscore","synthetic":false,"types":["syn::token::Underscore"]},{"text":"impl Hash for Abstract","synthetic":false,"types":["syn::token::Abstract"]},{"text":"impl Hash for As","synthetic":false,"types":["syn::token::As"]},{"text":"impl Hash for Async","synthetic":false,"types":["syn::token::Async"]},{"text":"impl Hash for Auto","synthetic":false,"types":["syn::token::Auto"]},{"text":"impl Hash for Await","synthetic":false,"types":["syn::token::Await"]},{"text":"impl Hash for Become","synthetic":false,"types":["syn::token::Become"]},{"text":"impl Hash for Box","synthetic":false,"types":["syn::token::Box"]},{"text":"impl Hash for Break","synthetic":false,"types":["syn::token::Break"]},{"text":"impl Hash for Const","synthetic":false,"types":["syn::token::Const"]},{"text":"impl Hash for Continue","synthetic":false,"types":["syn::token::Continue"]},{"text":"impl Hash for Crate","synthetic":false,"types":["syn::token::Crate"]},{"text":"impl Hash for Default","synthetic":false,"types":["syn::token::Default"]},{"text":"impl Hash for Do","synthetic":false,"types":["syn::token::Do"]},{"text":"impl Hash for Dyn","synthetic":false,"types":["syn::token::Dyn"]},{"text":"impl Hash for Else","synthetic":false,"types":["syn::token::Else"]},{"text":"impl Hash for Enum","synthetic":false,"types":["syn::token::Enum"]},{"text":"impl Hash for Extern","synthetic":false,"types":["syn::token::Extern"]},{"text":"impl Hash for Final","synthetic":false,"types":["syn::token::Final"]},{"text":"impl Hash for Fn","synthetic":false,"types":["syn::token::Fn"]},{"text":"impl Hash for For","synthetic":false,"types":["syn::token::For"]},{"text":"impl Hash for If","synthetic":false,"types":["syn::token::If"]},{"text":"impl Hash for Impl","synthetic":false,"types":["syn::token::Impl"]},{"text":"impl Hash for In","synthetic":false,"types":["syn::token::In"]},{"text":"impl Hash for Let","synthetic":false,"types":["syn::token::Let"]},{"text":"impl Hash for Loop","synthetic":false,"types":["syn::token::Loop"]},{"text":"impl Hash for Macro","synthetic":false,"types":["syn::token::Macro"]},{"text":"impl Hash for Match","synthetic":false,"types":["syn::token::Match"]},{"text":"impl Hash for Mod","synthetic":false,"types":["syn::token::Mod"]},{"text":"impl Hash for Move","synthetic":false,"types":["syn::token::Move"]},{"text":"impl Hash for Mut","synthetic":false,"types":["syn::token::Mut"]},{"text":"impl Hash for Override","synthetic":false,"types":["syn::token::Override"]},{"text":"impl Hash for Priv","synthetic":false,"types":["syn::token::Priv"]},{"text":"impl Hash for Pub","synthetic":false,"types":["syn::token::Pub"]},{"text":"impl Hash for Ref","synthetic":false,"types":["syn::token::Ref"]},{"text":"impl Hash for Return","synthetic":false,"types":["syn::token::Return"]},{"text":"impl Hash for SelfType","synthetic":false,"types":["syn::token::SelfType"]},{"text":"impl Hash for SelfValue","synthetic":false,"types":["syn::token::SelfValue"]},{"text":"impl Hash for Static","synthetic":false,"types":["syn::token::Static"]},{"text":"impl Hash for Struct","synthetic":false,"types":["syn::token::Struct"]},{"text":"impl Hash for Super","synthetic":false,"types":["syn::token::Super"]},{"text":"impl Hash for Trait","synthetic":false,"types":["syn::token::Trait"]},{"text":"impl Hash for Try","synthetic":false,"types":["syn::token::Try"]},{"text":"impl Hash for Type","synthetic":false,"types":["syn::token::Type"]},{"text":"impl Hash for Typeof","synthetic":false,"types":["syn::token::Typeof"]},{"text":"impl Hash for Union","synthetic":false,"types":["syn::token::Union"]},{"text":"impl Hash for Unsafe","synthetic":false,"types":["syn::token::Unsafe"]},{"text":"impl Hash for Unsized","synthetic":false,"types":["syn::token::Unsized"]},{"text":"impl Hash for Use","synthetic":false,"types":["syn::token::Use"]},{"text":"impl Hash for Virtual","synthetic":false,"types":["syn::token::Virtual"]},{"text":"impl Hash for Where","synthetic":false,"types":["syn::token::Where"]},{"text":"impl Hash for While","synthetic":false,"types":["syn::token::While"]},{"text":"impl Hash for Yield","synthetic":false,"types":["syn::token::Yield"]},{"text":"impl Hash for Add","synthetic":false,"types":["syn::token::Add"]},{"text":"impl Hash for AddEq","synthetic":false,"types":["syn::token::AddEq"]},{"text":"impl Hash for And","synthetic":false,"types":["syn::token::And"]},{"text":"impl Hash for AndAnd","synthetic":false,"types":["syn::token::AndAnd"]},{"text":"impl Hash for AndEq","synthetic":false,"types":["syn::token::AndEq"]},{"text":"impl Hash for At","synthetic":false,"types":["syn::token::At"]},{"text":"impl Hash for Bang","synthetic":false,"types":["syn::token::Bang"]},{"text":"impl Hash for Caret","synthetic":false,"types":["syn::token::Caret"]},{"text":"impl Hash for CaretEq","synthetic":false,"types":["syn::token::CaretEq"]},{"text":"impl Hash for Colon","synthetic":false,"types":["syn::token::Colon"]},{"text":"impl Hash for Colon2","synthetic":false,"types":["syn::token::Colon2"]},{"text":"impl Hash for Comma","synthetic":false,"types":["syn::token::Comma"]},{"text":"impl Hash for Div","synthetic":false,"types":["syn::token::Div"]},{"text":"impl Hash for DivEq","synthetic":false,"types":["syn::token::DivEq"]},{"text":"impl Hash for Dollar","synthetic":false,"types":["syn::token::Dollar"]},{"text":"impl Hash for Dot","synthetic":false,"types":["syn::token::Dot"]},{"text":"impl Hash for Dot2","synthetic":false,"types":["syn::token::Dot2"]},{"text":"impl Hash for Dot3","synthetic":false,"types":["syn::token::Dot3"]},{"text":"impl Hash for DotDotEq","synthetic":false,"types":["syn::token::DotDotEq"]},{"text":"impl Hash for Eq","synthetic":false,"types":["syn::token::Eq"]},{"text":"impl Hash for EqEq","synthetic":false,"types":["syn::token::EqEq"]},{"text":"impl Hash for Ge","synthetic":false,"types":["syn::token::Ge"]},{"text":"impl Hash for Gt","synthetic":false,"types":["syn::token::Gt"]},{"text":"impl Hash for Le","synthetic":false,"types":["syn::token::Le"]},{"text":"impl Hash for Lt","synthetic":false,"types":["syn::token::Lt"]},{"text":"impl Hash for MulEq","synthetic":false,"types":["syn::token::MulEq"]},{"text":"impl Hash for Ne","synthetic":false,"types":["syn::token::Ne"]},{"text":"impl Hash for Or","synthetic":false,"types":["syn::token::Or"]},{"text":"impl Hash for OrEq","synthetic":false,"types":["syn::token::OrEq"]},{"text":"impl Hash for OrOr","synthetic":false,"types":["syn::token::OrOr"]},{"text":"impl Hash for Pound","synthetic":false,"types":["syn::token::Pound"]},{"text":"impl Hash for Question","synthetic":false,"types":["syn::token::Question"]},{"text":"impl Hash for RArrow","synthetic":false,"types":["syn::token::RArrow"]},{"text":"impl Hash for LArrow","synthetic":false,"types":["syn::token::LArrow"]},{"text":"impl Hash for Rem","synthetic":false,"types":["syn::token::Rem"]},{"text":"impl Hash for RemEq","synthetic":false,"types":["syn::token::RemEq"]},{"text":"impl Hash for FatArrow","synthetic":false,"types":["syn::token::FatArrow"]},{"text":"impl Hash for Semi","synthetic":false,"types":["syn::token::Semi"]},{"text":"impl Hash for Shl","synthetic":false,"types":["syn::token::Shl"]},{"text":"impl Hash for ShlEq","synthetic":false,"types":["syn::token::ShlEq"]},{"text":"impl Hash for Shr","synthetic":false,"types":["syn::token::Shr"]},{"text":"impl Hash for ShrEq","synthetic":false,"types":["syn::token::ShrEq"]},{"text":"impl Hash for Star","synthetic":false,"types":["syn::token::Star"]},{"text":"impl Hash for Sub","synthetic":false,"types":["syn::token::Sub"]},{"text":"impl Hash for SubEq","synthetic":false,"types":["syn::token::SubEq"]},{"text":"impl Hash for Tilde","synthetic":false,"types":["syn::token::Tilde"]},{"text":"impl Hash for Brace","synthetic":false,"types":["syn::token::Brace"]},{"text":"impl Hash for Bracket","synthetic":false,"types":["syn::token::Bracket"]},{"text":"impl Hash for Paren","synthetic":false,"types":["syn::token::Paren"]},{"text":"impl Hash for Group","synthetic":false,"types":["syn::token::Group"]},{"text":"impl Hash for Member","synthetic":false,"types":["syn::expr::Member"]},{"text":"impl Hash for Index","synthetic":false,"types":["syn::expr::Index"]},{"text":"impl<'a> Hash for ImplGenerics<'a>","synthetic":false,"types":["syn::generics::ImplGenerics"]},{"text":"impl<'a> Hash for TypeGenerics<'a>","synthetic":false,"types":["syn::generics::TypeGenerics"]},{"text":"impl<'a> Hash for Turbofish<'a>","synthetic":false,"types":["syn::generics::Turbofish"]},{"text":"impl Hash for Lifetime","synthetic":false,"types":["syn::lifetime::Lifetime"]},{"text":"impl Hash for LitStr","synthetic":false,"types":["syn::lit::LitStr"]},{"text":"impl Hash for LitByteStr","synthetic":false,"types":["syn::lit::LitByteStr"]},{"text":"impl Hash for LitByte","synthetic":false,"types":["syn::lit::LitByte"]},{"text":"impl Hash for LitChar","synthetic":false,"types":["syn::lit::LitChar"]},{"text":"impl Hash for LitInt","synthetic":false,"types":["syn::lit::LitInt"]},{"text":"impl Hash for LitFloat","synthetic":false,"types":["syn::lit::LitFloat"]},{"text":"impl<T, P> Hash for Punctuated<T, P> where
    T: Hash,
    P: Hash, ","synthetic":false,"types":["syn::punctuated::Punctuated"]},{"text":"impl Hash for Abi","synthetic":false,"types":["syn::ty::Abi"]},{"text":"impl Hash for AngleBracketedGenericArguments","synthetic":false,"types":["syn::path::AngleBracketedGenericArguments"]},{"text":"impl Hash for AttrStyle","synthetic":false,"types":["syn::attr::AttrStyle"]},{"text":"impl Hash for Attribute","synthetic":false,"types":["syn::attr::Attribute"]},{"text":"impl Hash for BareFnArg","synthetic":false,"types":["syn::ty::BareFnArg"]},{"text":"impl Hash for BinOp","synthetic":false,"types":["syn::op::BinOp"]},{"text":"impl Hash for Binding","synthetic":false,"types":["syn::path::Binding"]},{"text":"impl Hash for BoundLifetimes","synthetic":false,"types":["syn::generics::BoundLifetimes"]},{"text":"impl Hash for ConstParam","synthetic":false,"types":["syn::generics::ConstParam"]},{"text":"impl Hash for Constraint","synthetic":false,"types":["syn::path::Constraint"]},{"text":"impl Hash for Data","synthetic":false,"types":["syn::derive::Data"]},{"text":"impl Hash for DataEnum","synthetic":false,"types":["syn::derive::DataEnum"]},{"text":"impl Hash for DataStruct","synthetic":false,"types":["syn::derive::DataStruct"]},{"text":"impl Hash for DataUnion","synthetic":false,"types":["syn::derive::DataUnion"]},{"text":"impl Hash for DeriveInput","synthetic":false,"types":["syn::derive::DeriveInput"]},{"text":"impl Hash for Expr","synthetic":false,"types":["syn::expr::Expr"]},{"text":"impl Hash for ExprBinary","synthetic":false,"types":["syn::expr::ExprBinary"]},{"text":"impl Hash for ExprCall","synthetic":false,"types":["syn::expr::ExprCall"]},{"text":"impl Hash for ExprCast","synthetic":false,"types":["syn::expr::ExprCast"]},{"text":"impl Hash for ExprField","synthetic":false,"types":["syn::expr::ExprField"]},{"text":"impl Hash for ExprIndex","synthetic":false,"types":["syn::expr::ExprIndex"]},{"text":"impl Hash for ExprLit","synthetic":false,"types":["syn::expr::ExprLit"]},{"text":"impl Hash for ExprParen","synthetic":false,"types":["syn::expr::ExprParen"]},{"text":"impl Hash for ExprPath","synthetic":false,"types":["syn::expr::ExprPath"]},{"text":"impl Hash for ExprUnary","synthetic":false,"types":["syn::expr::ExprUnary"]},{"text":"impl Hash for Field","synthetic":false,"types":["syn::data::Field"]},{"text":"impl Hash for Fields","synthetic":false,"types":["syn::data::Fields"]},{"text":"impl Hash for FieldsNamed","synthetic":false,"types":["syn::data::FieldsNamed"]},{"text":"impl Hash for FieldsUnnamed","synthetic":false,"types":["syn::data::FieldsUnnamed"]},{"text":"impl Hash for GenericArgument","synthetic":false,"types":["syn::path::GenericArgument"]},{"text":"impl Hash for GenericParam","synthetic":false,"types":["syn::generics::GenericParam"]},{"text":"impl Hash for Generics","synthetic":false,"types":["syn::generics::Generics"]},{"text":"impl Hash for LifetimeDef","synthetic":false,"types":["syn::generics::LifetimeDef"]},{"text":"impl Hash for Lit","synthetic":false,"types":["syn::lit::Lit"]},{"text":"impl Hash for LitBool","synthetic":false,"types":["syn::lit::LitBool"]},{"text":"impl Hash for Macro","synthetic":false,"types":["syn::mac::Macro"]},{"text":"impl Hash for MacroDelimiter","synthetic":false,"types":["syn::mac::MacroDelimiter"]},{"text":"impl Hash for Meta","synthetic":false,"types":["syn::attr::Meta"]},{"text":"impl Hash for MetaList","synthetic":false,"types":["syn::attr::MetaList"]},{"text":"impl Hash for MetaNameValue","synthetic":false,"types":["syn::attr::MetaNameValue"]},{"text":"impl Hash for NestedMeta","synthetic":false,"types":["syn::attr::NestedMeta"]},{"text":"impl Hash for ParenthesizedGenericArguments","synthetic":false,"types":["syn::path::ParenthesizedGenericArguments"]},{"text":"impl Hash for Path","synthetic":false,"types":["syn::path::Path"]},{"text":"impl Hash for PathArguments","synthetic":false,"types":["syn::path::PathArguments"]},{"text":"impl Hash for PathSegment","synthetic":false,"types":["syn::path::PathSegment"]},{"text":"impl Hash for PredicateEq","synthetic":false,"types":["syn::generics::PredicateEq"]},{"text":"impl Hash for PredicateLifetime","synthetic":false,"types":["syn::generics::PredicateLifetime"]},{"text":"impl Hash for PredicateType","synthetic":false,"types":["syn::generics::PredicateType"]},{"text":"impl Hash for QSelf","synthetic":false,"types":["syn::path::QSelf"]},{"text":"impl Hash for ReturnType","synthetic":false,"types":["syn::ty::ReturnType"]},{"text":"impl Hash for TraitBound","synthetic":false,"types":["syn::generics::TraitBound"]},{"text":"impl Hash for TraitBoundModifier","synthetic":false,"types":["syn::generics::TraitBoundModifier"]},{"text":"impl Hash for Type","synthetic":false,"types":["syn::ty::Type"]},{"text":"impl Hash for TypeArray","synthetic":false,"types":["syn::ty::TypeArray"]},{"text":"impl Hash for TypeBareFn","synthetic":false,"types":["syn::ty::TypeBareFn"]},{"text":"impl Hash for TypeGroup","synthetic":false,"types":["syn::ty::TypeGroup"]},{"text":"impl Hash for TypeImplTrait","synthetic":false,"types":["syn::ty::TypeImplTrait"]},{"text":"impl Hash for TypeInfer","synthetic":false,"types":["syn::ty::TypeInfer"]},{"text":"impl Hash for TypeMacro","synthetic":false,"types":["syn::ty::TypeMacro"]},{"text":"impl Hash for TypeNever","synthetic":false,"types":["syn::ty::TypeNever"]},{"text":"impl Hash for TypeParam","synthetic":false,"types":["syn::generics::TypeParam"]},{"text":"impl Hash for TypeParamBound","synthetic":false,"types":["syn::generics::TypeParamBound"]},{"text":"impl Hash for TypeParen","synthetic":false,"types":["syn::ty::TypeParen"]},{"text":"impl Hash for TypePath","synthetic":false,"types":["syn::ty::TypePath"]},{"text":"impl Hash for TypePtr","synthetic":false,"types":["syn::ty::TypePtr"]},{"text":"impl Hash for TypeReference","synthetic":false,"types":["syn::ty::TypeReference"]},{"text":"impl Hash for TypeSlice","synthetic":false,"types":["syn::ty::TypeSlice"]},{"text":"impl Hash for TypeTraitObject","synthetic":false,"types":["syn::ty::TypeTraitObject"]},{"text":"impl Hash for TypeTuple","synthetic":false,"types":["syn::ty::TypeTuple"]},{"text":"impl Hash for UnOp","synthetic":false,"types":["syn::op::UnOp"]},{"text":"impl Hash for Variadic","synthetic":false,"types":["syn::ty::Variadic"]},{"text":"impl Hash for Variant","synthetic":false,"types":["syn::data::Variant"]},{"text":"impl Hash for VisCrate","synthetic":false,"types":["syn::data::VisCrate"]},{"text":"impl Hash for VisPublic","synthetic":false,"types":["syn::data::VisPublic"]},{"text":"impl Hash for VisRestricted","synthetic":false,"types":["syn::data::VisRestricted"]},{"text":"impl Hash for Visibility","synthetic":false,"types":["syn::data::Visibility"]},{"text":"impl Hash for WhereClause","synthetic":false,"types":["syn::generics::WhereClause"]},{"text":"impl Hash for WherePredicate","synthetic":false,"types":["syn::generics::WherePredicate"]}]; +implementors["synstructure"] = [{"text":"impl Hash for AddBounds","synthetic":false,"types":["synstructure::AddBounds"]},{"text":"impl Hash for BindStyle","synthetic":false,"types":["synstructure::BindStyle"]},{"text":"impl<'a> Hash for BindingInfo<'a>","synthetic":false,"types":["synstructure::BindingInfo"]},{"text":"impl<'a> Hash for VariantAst<'a>","synthetic":false,"types":["synstructure::VariantAst"]},{"text":"impl<'a> Hash for VariantInfo<'a>","synthetic":false,"types":["synstructure::VariantInfo"]},{"text":"impl<'a> Hash for Structure<'a>","synthetic":false,"types":["synstructure::Structure"]}]; if (window.register_implementors) {window.register_implementors(implementors);} else {window.pending_implementors = implementors;}})() \ No newline at end of file diff --git a/implementors/core/iter/traits/collect/trait.Extend.js b/implementors/core/iter/traits/collect/trait.Extend.js index 80863ef..9ff367f 100644 --- a/implementors/core/iter/traits/collect/trait.Extend.js +++ b/implementors/core/iter/traits/collect/trait.Extend.js @@ -1,4 +1,4 @@ (function() {var implementors = {}; -implementors["proc_macro2"] = [{"text":"impl Extend<TokenTree> for TokenStream","synthetic":false,"types":[]},{"text":"impl Extend<TokenStream> for TokenStream","synthetic":false,"types":[]}]; -implementors["syn"] = [{"text":"impl<T, P> Extend<T> for Punctuated<T, P> where
    P: Default, ","synthetic":false,"types":[]},{"text":"impl<T, P> Extend<Pair<T, P>> for Punctuated<T, P>","synthetic":false,"types":[]},{"text":"impl Extend<Error> for Error","synthetic":false,"types":[]}]; +implementors["proc_macro2"] = [{"text":"impl Extend<TokenTree> for TokenStream","synthetic":false,"types":["proc_macro2::TokenStream"]},{"text":"impl Extend<TokenStream> for TokenStream","synthetic":false,"types":["proc_macro2::TokenStream"]}]; +implementors["syn"] = [{"text":"impl<T, P> Extend<T> for Punctuated<T, P> where
    P: Default, ","synthetic":false,"types":["syn::punctuated::Punctuated"]},{"text":"impl<T, P> Extend<Pair<T, P>> for Punctuated<T, P>","synthetic":false,"types":["syn::punctuated::Punctuated"]},{"text":"impl Extend<Error> for Error","synthetic":false,"types":["syn::error::Error"]}]; if (window.register_implementors) {window.register_implementors(implementors);} else {window.pending_implementors = implementors;}})() \ No newline at end of file diff --git a/implementors/core/iter/traits/collect/trait.FromIterator.js b/implementors/core/iter/traits/collect/trait.FromIterator.js index 294105c..be7ee60 100644 --- a/implementors/core/iter/traits/collect/trait.FromIterator.js +++ b/implementors/core/iter/traits/collect/trait.FromIterator.js @@ -1,4 +1,4 @@ (function() {var implementors = {}; -implementors["proc_macro2"] = [{"text":"impl FromIterator<TokenTree> for TokenStream","synthetic":false,"types":[]},{"text":"impl FromIterator<TokenStream> for TokenStream","synthetic":false,"types":[]}]; -implementors["syn"] = [{"text":"impl<T, P> FromIterator<T> for Punctuated<T, P> where
    P: Default, ","synthetic":false,"types":[]},{"text":"impl<T, P> FromIterator<Pair<T, P>> for Punctuated<T, P>","synthetic":false,"types":[]}]; +implementors["proc_macro2"] = [{"text":"impl FromIterator<TokenTree> for TokenStream","synthetic":false,"types":["proc_macro2::TokenStream"]},{"text":"impl FromIterator<TokenStream> for TokenStream","synthetic":false,"types":["proc_macro2::TokenStream"]}]; +implementors["syn"] = [{"text":"impl<T, P> FromIterator<T> for Punctuated<T, P> where
    P: Default, ","synthetic":false,"types":["syn::punctuated::Punctuated"]},{"text":"impl<T, P> FromIterator<Pair<T, P>> for Punctuated<T, P>","synthetic":false,"types":["syn::punctuated::Punctuated"]}]; if (window.register_implementors) {window.register_implementors(implementors);} else {window.pending_implementors = implementors;}})() \ No newline at end of file diff --git a/implementors/core/iter/traits/collect/trait.IntoIterator.js b/implementors/core/iter/traits/collect/trait.IntoIterator.js index 31f2769..a845289 100644 --- a/implementors/core/iter/traits/collect/trait.IntoIterator.js +++ b/implementors/core/iter/traits/collect/trait.IntoIterator.js @@ -1,4 +1,4 @@ (function() {var implementors = {}; -implementors["proc_macro2"] = [{"text":"impl IntoIterator for TokenStream","synthetic":false,"types":[]}]; -implementors["syn"] = [{"text":"impl IntoIterator for Fields","synthetic":false,"types":[]},{"text":"impl<'a> IntoIterator for &'a Fields","synthetic":false,"types":[]},{"text":"impl<'a> IntoIterator for &'a mut Fields","synthetic":false,"types":[]},{"text":"impl<T, P> IntoIterator for Punctuated<T, P>","synthetic":false,"types":[]},{"text":"impl<'a, T, P> IntoIterator for &'a Punctuated<T, P>","synthetic":false,"types":[]},{"text":"impl<'a, T, P> IntoIterator for &'a mut Punctuated<T, P>","synthetic":false,"types":[]},{"text":"impl IntoIterator for Error","synthetic":false,"types":[]},{"text":"impl<'a> IntoIterator for &'a Error","synthetic":false,"types":[]}]; +implementors["proc_macro2"] = [{"text":"impl IntoIterator for TokenStream","synthetic":false,"types":["proc_macro2::TokenStream"]}]; +implementors["syn"] = [{"text":"impl IntoIterator for Fields","synthetic":false,"types":["syn::data::Fields"]},{"text":"impl<'a> IntoIterator for &'a Fields","synthetic":false,"types":["syn::data::Fields"]},{"text":"impl<'a> IntoIterator for &'a mut Fields","synthetic":false,"types":["syn::data::Fields"]},{"text":"impl<T, P> IntoIterator for Punctuated<T, P>","synthetic":false,"types":["syn::punctuated::Punctuated"]},{"text":"impl<'a, T, P> IntoIterator for &'a Punctuated<T, P>","synthetic":false,"types":["syn::punctuated::Punctuated"]},{"text":"impl<'a, T, P> IntoIterator for &'a mut Punctuated<T, P>","synthetic":false,"types":["syn::punctuated::Punctuated"]},{"text":"impl IntoIterator for Error","synthetic":false,"types":["syn::error::Error"]},{"text":"impl<'a> IntoIterator for &'a Error","synthetic":false,"types":["syn::error::Error"]}]; if (window.register_implementors) {window.register_implementors(implementors);} else {window.pending_implementors = implementors;}})() \ No newline at end of file diff --git a/implementors/core/iter/traits/double_ended/trait.DoubleEndedIterator.js b/implementors/core/iter/traits/double_ended/trait.DoubleEndedIterator.js index 549ff7b..0333b3b 100644 --- a/implementors/core/iter/traits/double_ended/trait.DoubleEndedIterator.js +++ b/implementors/core/iter/traits/double_ended/trait.DoubleEndedIterator.js @@ -1,3 +1,3 @@ (function() {var implementors = {}; -implementors["syn"] = [{"text":"impl<'a, T, P> DoubleEndedIterator for Pairs<'a, T, P>","synthetic":false,"types":[]},{"text":"impl<'a, T, P> DoubleEndedIterator for PairsMut<'a, T, P>","synthetic":false,"types":[]},{"text":"impl<T, P> DoubleEndedIterator for IntoPairs<T, P>","synthetic":false,"types":[]},{"text":"impl<T> DoubleEndedIterator for IntoIter<T>","synthetic":false,"types":[]},{"text":"impl<'a, T> DoubleEndedIterator for Iter<'a, T>","synthetic":false,"types":[]},{"text":"impl<'a, T> DoubleEndedIterator for IterMut<'a, T>","synthetic":false,"types":[]}]; +implementors["syn"] = [{"text":"impl<'a, T, P> DoubleEndedIterator for Pairs<'a, T, P>","synthetic":false,"types":["syn::punctuated::Pairs"]},{"text":"impl<'a, T, P> DoubleEndedIterator for PairsMut<'a, T, P>","synthetic":false,"types":["syn::punctuated::PairsMut"]},{"text":"impl<T, P> DoubleEndedIterator for IntoPairs<T, P>","synthetic":false,"types":["syn::punctuated::IntoPairs"]},{"text":"impl<T> DoubleEndedIterator for IntoIter<T>","synthetic":false,"types":["syn::punctuated::IntoIter"]},{"text":"impl<'a, T> DoubleEndedIterator for Iter<'a, T>","synthetic":false,"types":["syn::punctuated::Iter"]},{"text":"impl<'a, T> DoubleEndedIterator for IterMut<'a, T>","synthetic":false,"types":["syn::punctuated::IterMut"]}]; if (window.register_implementors) {window.register_implementors(implementors);} else {window.pending_implementors = implementors;}})() \ No newline at end of file diff --git a/implementors/core/iter/traits/exact_size/trait.ExactSizeIterator.js b/implementors/core/iter/traits/exact_size/trait.ExactSizeIterator.js index 494f824..30ef990 100644 --- a/implementors/core/iter/traits/exact_size/trait.ExactSizeIterator.js +++ b/implementors/core/iter/traits/exact_size/trait.ExactSizeIterator.js @@ -1,3 +1,3 @@ (function() {var implementors = {}; -implementors["syn"] = [{"text":"impl<'a, T, P> ExactSizeIterator for Pairs<'a, T, P>","synthetic":false,"types":[]},{"text":"impl<'a, T, P> ExactSizeIterator for PairsMut<'a, T, P>","synthetic":false,"types":[]},{"text":"impl<T, P> ExactSizeIterator for IntoPairs<T, P>","synthetic":false,"types":[]},{"text":"impl<T> ExactSizeIterator for IntoIter<T>","synthetic":false,"types":[]},{"text":"impl<'a, T> ExactSizeIterator for Iter<'a, T>","synthetic":false,"types":[]},{"text":"impl<'a, T> ExactSizeIterator for IterMut<'a, T>","synthetic":false,"types":[]}]; +implementors["syn"] = [{"text":"impl<'a, T, P> ExactSizeIterator for Pairs<'a, T, P>","synthetic":false,"types":["syn::punctuated::Pairs"]},{"text":"impl<'a, T, P> ExactSizeIterator for PairsMut<'a, T, P>","synthetic":false,"types":["syn::punctuated::PairsMut"]},{"text":"impl<T, P> ExactSizeIterator for IntoPairs<T, P>","synthetic":false,"types":["syn::punctuated::IntoPairs"]},{"text":"impl<T> ExactSizeIterator for IntoIter<T>","synthetic":false,"types":["syn::punctuated::IntoIter"]},{"text":"impl<'a, T> ExactSizeIterator for Iter<'a, T>","synthetic":false,"types":["syn::punctuated::Iter"]},{"text":"impl<'a, T> ExactSizeIterator for IterMut<'a, T>","synthetic":false,"types":["syn::punctuated::IterMut"]}]; if (window.register_implementors) {window.register_implementors(implementors);} else {window.pending_implementors = implementors;}})() \ No newline at end of file diff --git a/implementors/core/iter/traits/iterator/trait.Iterator.js b/implementors/core/iter/traits/iterator/trait.Iterator.js index f2f9888..a732bea 100644 --- a/implementors/core/iter/traits/iterator/trait.Iterator.js +++ b/implementors/core/iter/traits/iterator/trait.Iterator.js @@ -1,4 +1,4 @@ (function() {var implementors = {}; -implementors["proc_macro2"] = [{"text":"impl Iterator for IntoIter","synthetic":false,"types":[]}]; -implementors["syn"] = [{"text":"impl<'a, T, P> Iterator for Pairs<'a, T, P>","synthetic":false,"types":[]},{"text":"impl<'a, T, P> Iterator for PairsMut<'a, T, P>","synthetic":false,"types":[]},{"text":"impl<T, P> Iterator for IntoPairs<T, P>","synthetic":false,"types":[]},{"text":"impl<T> Iterator for IntoIter<T>","synthetic":false,"types":[]},{"text":"impl<'a, T> Iterator for Iter<'a, T>","synthetic":false,"types":[]},{"text":"impl<'a, T> Iterator for IterMut<'a, T>","synthetic":false,"types":[]}]; +implementors["proc_macro2"] = [{"text":"impl Iterator for IntoIter","synthetic":false,"types":["proc_macro2::token_stream::IntoIter"]}]; +implementors["syn"] = [{"text":"impl<'a, T, P> Iterator for Pairs<'a, T, P>","synthetic":false,"types":["syn::punctuated::Pairs"]},{"text":"impl<'a, T, P> Iterator for PairsMut<'a, T, P>","synthetic":false,"types":["syn::punctuated::PairsMut"]},{"text":"impl<T, P> Iterator for IntoPairs<T, P>","synthetic":false,"types":["syn::punctuated::IntoPairs"]},{"text":"impl<T> Iterator for IntoIter<T>","synthetic":false,"types":["syn::punctuated::IntoIter"]},{"text":"impl<'a, T> Iterator for Iter<'a, T>","synthetic":false,"types":["syn::punctuated::Iter"]},{"text":"impl<'a, T> Iterator for IterMut<'a, T>","synthetic":false,"types":["syn::punctuated::IterMut"]}]; if (window.register_implementors) {window.register_implementors(implementors);} else {window.pending_implementors = implementors;}})() \ No newline at end of file diff --git a/implementors/core/marker/trait.Copy.js b/implementors/core/marker/trait.Copy.js index d45e5fc..c924b63 100644 --- a/implementors/core/marker/trait.Copy.js +++ b/implementors/core/marker/trait.Copy.js @@ -1,8 +1,8 @@ (function() {var implementors = {}; -implementors["delog"] = [{"text":"impl Copy for Statistics","synthetic":false,"types":[]},{"text":"impl Copy for DefaultRenderer","synthetic":false,"types":[]},{"text":"impl Copy for RipgrepRenderer","synthetic":false,"types":[]}]; -implementors["flexiber"] = [{"text":"impl Copy for Error","synthetic":false,"types":[]},{"text":"impl Copy for ErrorKind","synthetic":false,"types":[]},{"text":"impl Copy for Length","synthetic":false,"types":[]},{"text":"impl Copy for SimpleTag","synthetic":false,"types":[]},{"text":"impl<'a> Copy for Slice<'a>","synthetic":false,"types":[]},{"text":"impl Copy for Class","synthetic":false,"types":[]},{"text":"impl Copy for Tag","synthetic":false,"types":[]},{"text":"impl<V: Copy, T: Copy> Copy for TaggedValue<V, T>","synthetic":false,"types":[]}]; -implementors["log"] = [{"text":"impl Copy for Level","synthetic":false,"types":[]},{"text":"impl Copy for LevelFilter","synthetic":false,"types":[]}]; -implementors["proc_macro2"] = [{"text":"impl Copy for Span","synthetic":false,"types":[]},{"text":"impl Copy for Delimiter","synthetic":false,"types":[]},{"text":"impl Copy for Spacing","synthetic":false,"types":[]}]; -implementors["syn"] = [{"text":"impl Copy for Underscore","synthetic":false,"types":[]},{"text":"impl Copy for Abstract","synthetic":false,"types":[]},{"text":"impl Copy for As","synthetic":false,"types":[]},{"text":"impl Copy for Async","synthetic":false,"types":[]},{"text":"impl Copy for Auto","synthetic":false,"types":[]},{"text":"impl Copy for Await","synthetic":false,"types":[]},{"text":"impl Copy for Become","synthetic":false,"types":[]},{"text":"impl Copy for Box","synthetic":false,"types":[]},{"text":"impl Copy for Break","synthetic":false,"types":[]},{"text":"impl Copy for Const","synthetic":false,"types":[]},{"text":"impl Copy for Continue","synthetic":false,"types":[]},{"text":"impl Copy for Crate","synthetic":false,"types":[]},{"text":"impl Copy for Default","synthetic":false,"types":[]},{"text":"impl Copy for Do","synthetic":false,"types":[]},{"text":"impl Copy for Dyn","synthetic":false,"types":[]},{"text":"impl Copy for Else","synthetic":false,"types":[]},{"text":"impl Copy for Enum","synthetic":false,"types":[]},{"text":"impl Copy for Extern","synthetic":false,"types":[]},{"text":"impl Copy for Final","synthetic":false,"types":[]},{"text":"impl Copy for Fn","synthetic":false,"types":[]},{"text":"impl Copy for For","synthetic":false,"types":[]},{"text":"impl Copy for If","synthetic":false,"types":[]},{"text":"impl Copy for Impl","synthetic":false,"types":[]},{"text":"impl Copy for In","synthetic":false,"types":[]},{"text":"impl Copy for Let","synthetic":false,"types":[]},{"text":"impl Copy for Loop","synthetic":false,"types":[]},{"text":"impl Copy for Macro","synthetic":false,"types":[]},{"text":"impl Copy for Match","synthetic":false,"types":[]},{"text":"impl Copy for Mod","synthetic":false,"types":[]},{"text":"impl Copy for Move","synthetic":false,"types":[]},{"text":"impl Copy for Mut","synthetic":false,"types":[]},{"text":"impl Copy for Override","synthetic":false,"types":[]},{"text":"impl Copy for Priv","synthetic":false,"types":[]},{"text":"impl Copy for Pub","synthetic":false,"types":[]},{"text":"impl Copy for Ref","synthetic":false,"types":[]},{"text":"impl Copy for Return","synthetic":false,"types":[]},{"text":"impl Copy for SelfType","synthetic":false,"types":[]},{"text":"impl Copy for SelfValue","synthetic":false,"types":[]},{"text":"impl Copy for Static","synthetic":false,"types":[]},{"text":"impl Copy for Struct","synthetic":false,"types":[]},{"text":"impl Copy for Super","synthetic":false,"types":[]},{"text":"impl Copy for Trait","synthetic":false,"types":[]},{"text":"impl Copy for Try","synthetic":false,"types":[]},{"text":"impl Copy for Type","synthetic":false,"types":[]},{"text":"impl Copy for Typeof","synthetic":false,"types":[]},{"text":"impl Copy for Union","synthetic":false,"types":[]},{"text":"impl Copy for Unsafe","synthetic":false,"types":[]},{"text":"impl Copy for Unsized","synthetic":false,"types":[]},{"text":"impl Copy for Use","synthetic":false,"types":[]},{"text":"impl Copy for Virtual","synthetic":false,"types":[]},{"text":"impl Copy for Where","synthetic":false,"types":[]},{"text":"impl Copy for While","synthetic":false,"types":[]},{"text":"impl Copy for Yield","synthetic":false,"types":[]},{"text":"impl Copy for Add","synthetic":false,"types":[]},{"text":"impl Copy for AddEq","synthetic":false,"types":[]},{"text":"impl Copy for And","synthetic":false,"types":[]},{"text":"impl Copy for AndAnd","synthetic":false,"types":[]},{"text":"impl Copy for AndEq","synthetic":false,"types":[]},{"text":"impl Copy for At","synthetic":false,"types":[]},{"text":"impl Copy for Bang","synthetic":false,"types":[]},{"text":"impl Copy for Caret","synthetic":false,"types":[]},{"text":"impl Copy for CaretEq","synthetic":false,"types":[]},{"text":"impl Copy for Colon","synthetic":false,"types":[]},{"text":"impl Copy for Colon2","synthetic":false,"types":[]},{"text":"impl Copy for Comma","synthetic":false,"types":[]},{"text":"impl Copy for Div","synthetic":false,"types":[]},{"text":"impl Copy for DivEq","synthetic":false,"types":[]},{"text":"impl Copy for Dollar","synthetic":false,"types":[]},{"text":"impl Copy for Dot","synthetic":false,"types":[]},{"text":"impl Copy for Dot2","synthetic":false,"types":[]},{"text":"impl Copy for Dot3","synthetic":false,"types":[]},{"text":"impl Copy for DotDotEq","synthetic":false,"types":[]},{"text":"impl Copy for Eq","synthetic":false,"types":[]},{"text":"impl Copy for EqEq","synthetic":false,"types":[]},{"text":"impl Copy for Ge","synthetic":false,"types":[]},{"text":"impl Copy for Gt","synthetic":false,"types":[]},{"text":"impl Copy for Le","synthetic":false,"types":[]},{"text":"impl Copy for Lt","synthetic":false,"types":[]},{"text":"impl Copy for MulEq","synthetic":false,"types":[]},{"text":"impl Copy for Ne","synthetic":false,"types":[]},{"text":"impl Copy for Or","synthetic":false,"types":[]},{"text":"impl Copy for OrEq","synthetic":false,"types":[]},{"text":"impl Copy for OrOr","synthetic":false,"types":[]},{"text":"impl Copy for Pound","synthetic":false,"types":[]},{"text":"impl Copy for Question","synthetic":false,"types":[]},{"text":"impl Copy for RArrow","synthetic":false,"types":[]},{"text":"impl Copy for LArrow","synthetic":false,"types":[]},{"text":"impl Copy for Rem","synthetic":false,"types":[]},{"text":"impl Copy for RemEq","synthetic":false,"types":[]},{"text":"impl Copy for FatArrow","synthetic":false,"types":[]},{"text":"impl Copy for Semi","synthetic":false,"types":[]},{"text":"impl Copy for Shl","synthetic":false,"types":[]},{"text":"impl Copy for ShlEq","synthetic":false,"types":[]},{"text":"impl Copy for Shr","synthetic":false,"types":[]},{"text":"impl Copy for ShrEq","synthetic":false,"types":[]},{"text":"impl Copy for Star","synthetic":false,"types":[]},{"text":"impl Copy for Sub","synthetic":false,"types":[]},{"text":"impl Copy for SubEq","synthetic":false,"types":[]},{"text":"impl Copy for Tilde","synthetic":false,"types":[]},{"text":"impl Copy for Brace","synthetic":false,"types":[]},{"text":"impl Copy for Bracket","synthetic":false,"types":[]},{"text":"impl Copy for Paren","synthetic":false,"types":[]},{"text":"impl Copy for Group","synthetic":false,"types":[]},{"text":"impl<'a> Copy for Cursor<'a>","synthetic":false,"types":[]},{"text":"impl Copy for AttrStyle","synthetic":false,"types":[]},{"text":"impl Copy for BinOp","synthetic":false,"types":[]},{"text":"impl Copy for TraitBoundModifier","synthetic":false,"types":[]},{"text":"impl Copy for UnOp","synthetic":false,"types":[]},{"text":"impl<'c, 'a> Copy for StepCursor<'c, 'a>","synthetic":false,"types":[]}]; -implementors["synstructure"] = [{"text":"impl Copy for AddBounds","synthetic":false,"types":[]},{"text":"impl Copy for BindStyle","synthetic":false,"types":[]},{"text":"impl<'a> Copy for VariantAst<'a>","synthetic":false,"types":[]}]; +implementors["delog"] = [{"text":"impl Copy for Statistics","synthetic":false,"types":["delog::logger::Statistics"]},{"text":"impl Copy for DefaultRenderer","synthetic":false,"types":["delog::render::DefaultRenderer"]},{"text":"impl Copy for RipgrepRenderer","synthetic":false,"types":["delog::render::RipgrepRenderer"]}]; +implementors["flexiber"] = [{"text":"impl Copy for Error","synthetic":false,"types":["flexiber::error::Error"]},{"text":"impl Copy for ErrorKind","synthetic":false,"types":["flexiber::error::ErrorKind"]},{"text":"impl Copy for Length","synthetic":false,"types":["flexiber::length::Length"]},{"text":"impl Copy for SimpleTag","synthetic":false,"types":["flexiber::simpletag::SimpleTag"]},{"text":"impl<'a> Copy for Slice<'a>","synthetic":false,"types":["flexiber::slice::Slice"]},{"text":"impl Copy for Class","synthetic":false,"types":["flexiber::tag::Class"]},{"text":"impl Copy for Tag","synthetic":false,"types":["flexiber::tag::Tag"]},{"text":"impl<V: Copy, T: Copy> Copy for TaggedValue<V, T>","synthetic":false,"types":["flexiber::tagged::TaggedValue"]}]; +implementors["log"] = [{"text":"impl Copy for Level","synthetic":false,"types":["log::Level"]},{"text":"impl Copy for LevelFilter","synthetic":false,"types":["log::LevelFilter"]}]; +implementors["proc_macro2"] = [{"text":"impl Copy for Span","synthetic":false,"types":["proc_macro2::Span"]},{"text":"impl Copy for Delimiter","synthetic":false,"types":["proc_macro2::Delimiter"]},{"text":"impl Copy for Spacing","synthetic":false,"types":["proc_macro2::Spacing"]}]; +implementors["syn"] = [{"text":"impl Copy for Underscore","synthetic":false,"types":["syn::token::Underscore"]},{"text":"impl Copy for Abstract","synthetic":false,"types":["syn::token::Abstract"]},{"text":"impl Copy for As","synthetic":false,"types":["syn::token::As"]},{"text":"impl Copy for Async","synthetic":false,"types":["syn::token::Async"]},{"text":"impl Copy for Auto","synthetic":false,"types":["syn::token::Auto"]},{"text":"impl Copy for Await","synthetic":false,"types":["syn::token::Await"]},{"text":"impl Copy for Become","synthetic":false,"types":["syn::token::Become"]},{"text":"impl Copy for Box","synthetic":false,"types":["syn::token::Box"]},{"text":"impl Copy for Break","synthetic":false,"types":["syn::token::Break"]},{"text":"impl Copy for Const","synthetic":false,"types":["syn::token::Const"]},{"text":"impl Copy for Continue","synthetic":false,"types":["syn::token::Continue"]},{"text":"impl Copy for Crate","synthetic":false,"types":["syn::token::Crate"]},{"text":"impl Copy for Default","synthetic":false,"types":["syn::token::Default"]},{"text":"impl Copy for Do","synthetic":false,"types":["syn::token::Do"]},{"text":"impl Copy for Dyn","synthetic":false,"types":["syn::token::Dyn"]},{"text":"impl Copy for Else","synthetic":false,"types":["syn::token::Else"]},{"text":"impl Copy for Enum","synthetic":false,"types":["syn::token::Enum"]},{"text":"impl Copy for Extern","synthetic":false,"types":["syn::token::Extern"]},{"text":"impl Copy for Final","synthetic":false,"types":["syn::token::Final"]},{"text":"impl Copy for Fn","synthetic":false,"types":["syn::token::Fn"]},{"text":"impl Copy for For","synthetic":false,"types":["syn::token::For"]},{"text":"impl Copy for If","synthetic":false,"types":["syn::token::If"]},{"text":"impl Copy for Impl","synthetic":false,"types":["syn::token::Impl"]},{"text":"impl Copy for In","synthetic":false,"types":["syn::token::In"]},{"text":"impl Copy for Let","synthetic":false,"types":["syn::token::Let"]},{"text":"impl Copy for Loop","synthetic":false,"types":["syn::token::Loop"]},{"text":"impl Copy for Macro","synthetic":false,"types":["syn::token::Macro"]},{"text":"impl Copy for Match","synthetic":false,"types":["syn::token::Match"]},{"text":"impl Copy for Mod","synthetic":false,"types":["syn::token::Mod"]},{"text":"impl Copy for Move","synthetic":false,"types":["syn::token::Move"]},{"text":"impl Copy for Mut","synthetic":false,"types":["syn::token::Mut"]},{"text":"impl Copy for Override","synthetic":false,"types":["syn::token::Override"]},{"text":"impl Copy for Priv","synthetic":false,"types":["syn::token::Priv"]},{"text":"impl Copy for Pub","synthetic":false,"types":["syn::token::Pub"]},{"text":"impl Copy for Ref","synthetic":false,"types":["syn::token::Ref"]},{"text":"impl Copy for Return","synthetic":false,"types":["syn::token::Return"]},{"text":"impl Copy for SelfType","synthetic":false,"types":["syn::token::SelfType"]},{"text":"impl Copy for SelfValue","synthetic":false,"types":["syn::token::SelfValue"]},{"text":"impl Copy for Static","synthetic":false,"types":["syn::token::Static"]},{"text":"impl Copy for Struct","synthetic":false,"types":["syn::token::Struct"]},{"text":"impl Copy for Super","synthetic":false,"types":["syn::token::Super"]},{"text":"impl Copy for Trait","synthetic":false,"types":["syn::token::Trait"]},{"text":"impl Copy for Try","synthetic":false,"types":["syn::token::Try"]},{"text":"impl Copy for Type","synthetic":false,"types":["syn::token::Type"]},{"text":"impl Copy for Typeof","synthetic":false,"types":["syn::token::Typeof"]},{"text":"impl Copy for Union","synthetic":false,"types":["syn::token::Union"]},{"text":"impl Copy for Unsafe","synthetic":false,"types":["syn::token::Unsafe"]},{"text":"impl Copy for Unsized","synthetic":false,"types":["syn::token::Unsized"]},{"text":"impl Copy for Use","synthetic":false,"types":["syn::token::Use"]},{"text":"impl Copy for Virtual","synthetic":false,"types":["syn::token::Virtual"]},{"text":"impl Copy for Where","synthetic":false,"types":["syn::token::Where"]},{"text":"impl Copy for While","synthetic":false,"types":["syn::token::While"]},{"text":"impl Copy for Yield","synthetic":false,"types":["syn::token::Yield"]},{"text":"impl Copy for Add","synthetic":false,"types":["syn::token::Add"]},{"text":"impl Copy for AddEq","synthetic":false,"types":["syn::token::AddEq"]},{"text":"impl Copy for And","synthetic":false,"types":["syn::token::And"]},{"text":"impl Copy for AndAnd","synthetic":false,"types":["syn::token::AndAnd"]},{"text":"impl Copy for AndEq","synthetic":false,"types":["syn::token::AndEq"]},{"text":"impl Copy for At","synthetic":false,"types":["syn::token::At"]},{"text":"impl Copy for Bang","synthetic":false,"types":["syn::token::Bang"]},{"text":"impl Copy for Caret","synthetic":false,"types":["syn::token::Caret"]},{"text":"impl Copy for CaretEq","synthetic":false,"types":["syn::token::CaretEq"]},{"text":"impl Copy for Colon","synthetic":false,"types":["syn::token::Colon"]},{"text":"impl Copy for Colon2","synthetic":false,"types":["syn::token::Colon2"]},{"text":"impl Copy for Comma","synthetic":false,"types":["syn::token::Comma"]},{"text":"impl Copy for Div","synthetic":false,"types":["syn::token::Div"]},{"text":"impl Copy for DivEq","synthetic":false,"types":["syn::token::DivEq"]},{"text":"impl Copy for Dollar","synthetic":false,"types":["syn::token::Dollar"]},{"text":"impl Copy for Dot","synthetic":false,"types":["syn::token::Dot"]},{"text":"impl Copy for Dot2","synthetic":false,"types":["syn::token::Dot2"]},{"text":"impl Copy for Dot3","synthetic":false,"types":["syn::token::Dot3"]},{"text":"impl Copy for DotDotEq","synthetic":false,"types":["syn::token::DotDotEq"]},{"text":"impl Copy for Eq","synthetic":false,"types":["syn::token::Eq"]},{"text":"impl Copy for EqEq","synthetic":false,"types":["syn::token::EqEq"]},{"text":"impl Copy for Ge","synthetic":false,"types":["syn::token::Ge"]},{"text":"impl Copy for Gt","synthetic":false,"types":["syn::token::Gt"]},{"text":"impl Copy for Le","synthetic":false,"types":["syn::token::Le"]},{"text":"impl Copy for Lt","synthetic":false,"types":["syn::token::Lt"]},{"text":"impl Copy for MulEq","synthetic":false,"types":["syn::token::MulEq"]},{"text":"impl Copy for Ne","synthetic":false,"types":["syn::token::Ne"]},{"text":"impl Copy for Or","synthetic":false,"types":["syn::token::Or"]},{"text":"impl Copy for OrEq","synthetic":false,"types":["syn::token::OrEq"]},{"text":"impl Copy for OrOr","synthetic":false,"types":["syn::token::OrOr"]},{"text":"impl Copy for Pound","synthetic":false,"types":["syn::token::Pound"]},{"text":"impl Copy for Question","synthetic":false,"types":["syn::token::Question"]},{"text":"impl Copy for RArrow","synthetic":false,"types":["syn::token::RArrow"]},{"text":"impl Copy for LArrow","synthetic":false,"types":["syn::token::LArrow"]},{"text":"impl Copy for Rem","synthetic":false,"types":["syn::token::Rem"]},{"text":"impl Copy for RemEq","synthetic":false,"types":["syn::token::RemEq"]},{"text":"impl Copy for FatArrow","synthetic":false,"types":["syn::token::FatArrow"]},{"text":"impl Copy for Semi","synthetic":false,"types":["syn::token::Semi"]},{"text":"impl Copy for Shl","synthetic":false,"types":["syn::token::Shl"]},{"text":"impl Copy for ShlEq","synthetic":false,"types":["syn::token::ShlEq"]},{"text":"impl Copy for Shr","synthetic":false,"types":["syn::token::Shr"]},{"text":"impl Copy for ShrEq","synthetic":false,"types":["syn::token::ShrEq"]},{"text":"impl Copy for Star","synthetic":false,"types":["syn::token::Star"]},{"text":"impl Copy for Sub","synthetic":false,"types":["syn::token::Sub"]},{"text":"impl Copy for SubEq","synthetic":false,"types":["syn::token::SubEq"]},{"text":"impl Copy for Tilde","synthetic":false,"types":["syn::token::Tilde"]},{"text":"impl Copy for Brace","synthetic":false,"types":["syn::token::Brace"]},{"text":"impl Copy for Bracket","synthetic":false,"types":["syn::token::Bracket"]},{"text":"impl Copy for Paren","synthetic":false,"types":["syn::token::Paren"]},{"text":"impl Copy for Group","synthetic":false,"types":["syn::token::Group"]},{"text":"impl<'a> Copy for Cursor<'a>","synthetic":false,"types":["syn::buffer::Cursor"]},{"text":"impl Copy for AttrStyle","synthetic":false,"types":["syn::attr::AttrStyle"]},{"text":"impl Copy for BinOp","synthetic":false,"types":["syn::op::BinOp"]},{"text":"impl Copy for TraitBoundModifier","synthetic":false,"types":["syn::generics::TraitBoundModifier"]},{"text":"impl Copy for UnOp","synthetic":false,"types":["syn::op::UnOp"]},{"text":"impl<'c, 'a> Copy for StepCursor<'c, 'a>","synthetic":false,"types":["syn::parse::StepCursor"]}]; +implementors["synstructure"] = [{"text":"impl Copy for AddBounds","synthetic":false,"types":["synstructure::AddBounds"]},{"text":"impl Copy for BindStyle","synthetic":false,"types":["synstructure::BindStyle"]},{"text":"impl<'a> Copy for VariantAst<'a>","synthetic":false,"types":["synstructure::VariantAst"]}]; if (window.register_implementors) {window.register_implementors(implementors);} else {window.pending_implementors = implementors;}})() \ No newline at end of file diff --git a/implementors/core/marker/trait.Freeze.js b/implementors/core/marker/trait.Freeze.js index 2e17e96..bc684a0 100644 --- a/implementors/core/marker/trait.Freeze.js +++ b/implementors/core/marker/trait.Freeze.js @@ -1,8 +1,8 @@ (function() {var implementors = {}; -implementors["delog"] = [{"text":"impl Freeze for U1","synthetic":true,"types":[]},{"text":"impl<'a, T: ?Sized, U, S> Freeze for HexStr<'a, T, U, S>","synthetic":true,"types":[]},{"text":"impl Freeze for Statistics","synthetic":true,"types":[]},{"text":"impl Freeze for DefaultRenderer","synthetic":true,"types":[]},{"text":"impl Freeze for RipgrepRenderer","synthetic":true,"types":[]}]; -implementors["flexiber"] = [{"text":"impl<'a> Freeze for Decoder<'a>","synthetic":true,"types":[]},{"text":"impl<'a> Freeze for Encoder<'a>","synthetic":true,"types":[]},{"text":"impl Freeze for Error","synthetic":true,"types":[]},{"text":"impl Freeze for ErrorKind","synthetic":true,"types":[]},{"text":"impl Freeze for Length","synthetic":true,"types":[]},{"text":"impl Freeze for SimpleTag","synthetic":true,"types":[]},{"text":"impl<'a> Freeze for Slice<'a>","synthetic":true,"types":[]},{"text":"impl Freeze for Class","synthetic":true,"types":[]},{"text":"impl Freeze for Tag","synthetic":true,"types":[]},{"text":"impl<V, T> Freeze for TaggedValue<V, T> where
    T: Freeze,
    V: Freeze, ","synthetic":true,"types":[]}]; -implementors["log"] = [{"text":"impl Freeze for Level","synthetic":true,"types":[]},{"text":"impl Freeze for LevelFilter","synthetic":true,"types":[]},{"text":"impl<'a> Freeze for Record<'a>","synthetic":true,"types":[]},{"text":"impl<'a> Freeze for RecordBuilder<'a>","synthetic":true,"types":[]},{"text":"impl<'a> Freeze for Metadata<'a>","synthetic":true,"types":[]},{"text":"impl<'a> Freeze for MetadataBuilder<'a>","synthetic":true,"types":[]},{"text":"impl Freeze for SetLoggerError","synthetic":true,"types":[]},{"text":"impl Freeze for ParseLevelError","synthetic":true,"types":[]}]; -implementors["proc_macro2"] = [{"text":"impl Freeze for IntoIter","synthetic":true,"types":[]},{"text":"impl Freeze for TokenStream","synthetic":true,"types":[]},{"text":"impl Freeze for LexError","synthetic":true,"types":[]},{"text":"impl Freeze for Span","synthetic":true,"types":[]},{"text":"impl Freeze for TokenTree","synthetic":true,"types":[]},{"text":"impl Freeze for Group","synthetic":true,"types":[]},{"text":"impl Freeze for Delimiter","synthetic":true,"types":[]},{"text":"impl Freeze for Punct","synthetic":true,"types":[]},{"text":"impl Freeze for Spacing","synthetic":true,"types":[]},{"text":"impl Freeze for Ident","synthetic":true,"types":[]},{"text":"impl Freeze for Literal","synthetic":true,"types":[]}]; -implementors["syn"] = [{"text":"impl Freeze for Underscore","synthetic":true,"types":[]},{"text":"impl Freeze for Abstract","synthetic":true,"types":[]},{"text":"impl Freeze for As","synthetic":true,"types":[]},{"text":"impl Freeze for Async","synthetic":true,"types":[]},{"text":"impl Freeze for Auto","synthetic":true,"types":[]},{"text":"impl Freeze for Await","synthetic":true,"types":[]},{"text":"impl Freeze for Become","synthetic":true,"types":[]},{"text":"impl Freeze for Box","synthetic":true,"types":[]},{"text":"impl Freeze for Break","synthetic":true,"types":[]},{"text":"impl Freeze for Const","synthetic":true,"types":[]},{"text":"impl Freeze for Continue","synthetic":true,"types":[]},{"text":"impl Freeze for Crate","synthetic":true,"types":[]},{"text":"impl Freeze for Default","synthetic":true,"types":[]},{"text":"impl Freeze for Do","synthetic":true,"types":[]},{"text":"impl Freeze for Dyn","synthetic":true,"types":[]},{"text":"impl Freeze for Else","synthetic":true,"types":[]},{"text":"impl Freeze for Enum","synthetic":true,"types":[]},{"text":"impl Freeze for Extern","synthetic":true,"types":[]},{"text":"impl Freeze for Final","synthetic":true,"types":[]},{"text":"impl Freeze for Fn","synthetic":true,"types":[]},{"text":"impl Freeze for For","synthetic":true,"types":[]},{"text":"impl Freeze for If","synthetic":true,"types":[]},{"text":"impl Freeze for Impl","synthetic":true,"types":[]},{"text":"impl Freeze for In","synthetic":true,"types":[]},{"text":"impl Freeze for Let","synthetic":true,"types":[]},{"text":"impl Freeze for Loop","synthetic":true,"types":[]},{"text":"impl Freeze for Macro","synthetic":true,"types":[]},{"text":"impl Freeze for Match","synthetic":true,"types":[]},{"text":"impl Freeze for Mod","synthetic":true,"types":[]},{"text":"impl Freeze for Move","synthetic":true,"types":[]},{"text":"impl Freeze for Mut","synthetic":true,"types":[]},{"text":"impl Freeze for Override","synthetic":true,"types":[]},{"text":"impl Freeze for Priv","synthetic":true,"types":[]},{"text":"impl Freeze for Pub","synthetic":true,"types":[]},{"text":"impl Freeze for Ref","synthetic":true,"types":[]},{"text":"impl Freeze for Return","synthetic":true,"types":[]},{"text":"impl Freeze for SelfType","synthetic":true,"types":[]},{"text":"impl Freeze for SelfValue","synthetic":true,"types":[]},{"text":"impl Freeze for Static","synthetic":true,"types":[]},{"text":"impl Freeze for Struct","synthetic":true,"types":[]},{"text":"impl Freeze for Super","synthetic":true,"types":[]},{"text":"impl Freeze for Trait","synthetic":true,"types":[]},{"text":"impl Freeze for Try","synthetic":true,"types":[]},{"text":"impl Freeze for Type","synthetic":true,"types":[]},{"text":"impl Freeze for Typeof","synthetic":true,"types":[]},{"text":"impl Freeze for Union","synthetic":true,"types":[]},{"text":"impl Freeze for Unsafe","synthetic":true,"types":[]},{"text":"impl Freeze for Unsized","synthetic":true,"types":[]},{"text":"impl Freeze for Use","synthetic":true,"types":[]},{"text":"impl Freeze for Virtual","synthetic":true,"types":[]},{"text":"impl Freeze for Where","synthetic":true,"types":[]},{"text":"impl Freeze for While","synthetic":true,"types":[]},{"text":"impl Freeze for Yield","synthetic":true,"types":[]},{"text":"impl Freeze for Add","synthetic":true,"types":[]},{"text":"impl Freeze for AddEq","synthetic":true,"types":[]},{"text":"impl Freeze for And","synthetic":true,"types":[]},{"text":"impl Freeze for AndAnd","synthetic":true,"types":[]},{"text":"impl Freeze for AndEq","synthetic":true,"types":[]},{"text":"impl Freeze for At","synthetic":true,"types":[]},{"text":"impl Freeze for Bang","synthetic":true,"types":[]},{"text":"impl Freeze for Caret","synthetic":true,"types":[]},{"text":"impl Freeze for CaretEq","synthetic":true,"types":[]},{"text":"impl Freeze for Colon","synthetic":true,"types":[]},{"text":"impl Freeze for Colon2","synthetic":true,"types":[]},{"text":"impl Freeze for Comma","synthetic":true,"types":[]},{"text":"impl Freeze for Div","synthetic":true,"types":[]},{"text":"impl Freeze for DivEq","synthetic":true,"types":[]},{"text":"impl Freeze for Dollar","synthetic":true,"types":[]},{"text":"impl Freeze for Dot","synthetic":true,"types":[]},{"text":"impl Freeze for Dot2","synthetic":true,"types":[]},{"text":"impl Freeze for Dot3","synthetic":true,"types":[]},{"text":"impl Freeze for DotDotEq","synthetic":true,"types":[]},{"text":"impl Freeze for Eq","synthetic":true,"types":[]},{"text":"impl Freeze for EqEq","synthetic":true,"types":[]},{"text":"impl Freeze for Ge","synthetic":true,"types":[]},{"text":"impl Freeze for Gt","synthetic":true,"types":[]},{"text":"impl Freeze for Le","synthetic":true,"types":[]},{"text":"impl Freeze for Lt","synthetic":true,"types":[]},{"text":"impl Freeze for MulEq","synthetic":true,"types":[]},{"text":"impl Freeze for Ne","synthetic":true,"types":[]},{"text":"impl Freeze for Or","synthetic":true,"types":[]},{"text":"impl Freeze for OrEq","synthetic":true,"types":[]},{"text":"impl Freeze for OrOr","synthetic":true,"types":[]},{"text":"impl Freeze for Pound","synthetic":true,"types":[]},{"text":"impl Freeze for Question","synthetic":true,"types":[]},{"text":"impl Freeze for RArrow","synthetic":true,"types":[]},{"text":"impl Freeze for LArrow","synthetic":true,"types":[]},{"text":"impl Freeze for Rem","synthetic":true,"types":[]},{"text":"impl Freeze for RemEq","synthetic":true,"types":[]},{"text":"impl Freeze for FatArrow","synthetic":true,"types":[]},{"text":"impl Freeze for Semi","synthetic":true,"types":[]},{"text":"impl Freeze for Shl","synthetic":true,"types":[]},{"text":"impl Freeze for ShlEq","synthetic":true,"types":[]},{"text":"impl Freeze for Shr","synthetic":true,"types":[]},{"text":"impl Freeze for ShrEq","synthetic":true,"types":[]},{"text":"impl Freeze for Star","synthetic":true,"types":[]},{"text":"impl Freeze for Sub","synthetic":true,"types":[]},{"text":"impl Freeze for SubEq","synthetic":true,"types":[]},{"text":"impl Freeze for Tilde","synthetic":true,"types":[]},{"text":"impl Freeze for Brace","synthetic":true,"types":[]},{"text":"impl Freeze for Bracket","synthetic":true,"types":[]},{"text":"impl Freeze for Paren","synthetic":true,"types":[]},{"text":"impl Freeze for Group","synthetic":true,"types":[]},{"text":"impl Freeze for Attribute","synthetic":true,"types":[]},{"text":"impl Freeze for AttrStyle","synthetic":true,"types":[]},{"text":"impl Freeze for Meta","synthetic":true,"types":[]},{"text":"impl Freeze for MetaList","synthetic":true,"types":[]},{"text":"impl Freeze for MetaNameValue","synthetic":true,"types":[]},{"text":"impl Freeze for NestedMeta","synthetic":true,"types":[]},{"text":"impl Freeze for Variant","synthetic":true,"types":[]},{"text":"impl Freeze for Fields","synthetic":true,"types":[]},{"text":"impl Freeze for FieldsNamed","synthetic":true,"types":[]},{"text":"impl Freeze for FieldsUnnamed","synthetic":true,"types":[]},{"text":"impl Freeze for Field","synthetic":true,"types":[]},{"text":"impl Freeze for Visibility","synthetic":true,"types":[]},{"text":"impl Freeze for VisPublic","synthetic":true,"types":[]},{"text":"impl Freeze for VisCrate","synthetic":true,"types":[]},{"text":"impl Freeze for VisRestricted","synthetic":true,"types":[]},{"text":"impl Freeze for Expr","synthetic":true,"types":[]},{"text":"impl Freeze for ExprArray","synthetic":true,"types":[]},{"text":"impl Freeze for ExprAssign","synthetic":true,"types":[]},{"text":"impl Freeze for ExprAssignOp","synthetic":true,"types":[]},{"text":"impl Freeze for ExprAsync","synthetic":true,"types":[]},{"text":"impl Freeze for ExprAwait","synthetic":true,"types":[]},{"text":"impl Freeze for ExprBinary","synthetic":true,"types":[]},{"text":"impl Freeze for ExprBlock","synthetic":true,"types":[]},{"text":"impl Freeze for ExprBox","synthetic":true,"types":[]},{"text":"impl Freeze for ExprBreak","synthetic":true,"types":[]},{"text":"impl Freeze for ExprCall","synthetic":true,"types":[]},{"text":"impl Freeze for ExprCast","synthetic":true,"types":[]},{"text":"impl Freeze for ExprClosure","synthetic":true,"types":[]},{"text":"impl Freeze for ExprContinue","synthetic":true,"types":[]},{"text":"impl Freeze for ExprField","synthetic":true,"types":[]},{"text":"impl Freeze for ExprForLoop","synthetic":true,"types":[]},{"text":"impl Freeze for ExprGroup","synthetic":true,"types":[]},{"text":"impl Freeze for ExprIf","synthetic":true,"types":[]},{"text":"impl Freeze for ExprIndex","synthetic":true,"types":[]},{"text":"impl Freeze for ExprLet","synthetic":true,"types":[]},{"text":"impl Freeze for ExprLit","synthetic":true,"types":[]},{"text":"impl Freeze for ExprLoop","synthetic":true,"types":[]},{"text":"impl Freeze for ExprMacro","synthetic":true,"types":[]},{"text":"impl Freeze for ExprMatch","synthetic":true,"types":[]},{"text":"impl Freeze for ExprMethodCall","synthetic":true,"types":[]},{"text":"impl Freeze for ExprParen","synthetic":true,"types":[]},{"text":"impl Freeze for ExprPath","synthetic":true,"types":[]},{"text":"impl Freeze for ExprRange","synthetic":true,"types":[]},{"text":"impl Freeze for ExprReference","synthetic":true,"types":[]},{"text":"impl Freeze for ExprRepeat","synthetic":true,"types":[]},{"text":"impl Freeze for ExprReturn","synthetic":true,"types":[]},{"text":"impl Freeze for ExprStruct","synthetic":true,"types":[]},{"text":"impl Freeze for ExprTry","synthetic":true,"types":[]},{"text":"impl Freeze for ExprTryBlock","synthetic":true,"types":[]},{"text":"impl Freeze for ExprTuple","synthetic":true,"types":[]},{"text":"impl Freeze for ExprType","synthetic":true,"types":[]},{"text":"impl Freeze for ExprUnary","synthetic":true,"types":[]},{"text":"impl Freeze for ExprUnsafe","synthetic":true,"types":[]},{"text":"impl Freeze for ExprWhile","synthetic":true,"types":[]},{"text":"impl Freeze for ExprYield","synthetic":true,"types":[]},{"text":"impl Freeze for Member","synthetic":true,"types":[]},{"text":"impl Freeze for Index","synthetic":true,"types":[]},{"text":"impl Freeze for Generics","synthetic":true,"types":[]},{"text":"impl Freeze for GenericParam","synthetic":true,"types":[]},{"text":"impl Freeze for TypeParam","synthetic":true,"types":[]},{"text":"impl Freeze for LifetimeDef","synthetic":true,"types":[]},{"text":"impl Freeze for ConstParam","synthetic":true,"types":[]},{"text":"impl<'a> Freeze for ImplGenerics<'a>","synthetic":true,"types":[]},{"text":"impl<'a> Freeze for TypeGenerics<'a>","synthetic":true,"types":[]},{"text":"impl<'a> Freeze for Turbofish<'a>","synthetic":true,"types":[]},{"text":"impl Freeze for BoundLifetimes","synthetic":true,"types":[]},{"text":"impl Freeze for TypeParamBound","synthetic":true,"types":[]},{"text":"impl Freeze for TraitBound","synthetic":true,"types":[]},{"text":"impl Freeze for TraitBoundModifier","synthetic":true,"types":[]},{"text":"impl Freeze for WhereClause","synthetic":true,"types":[]},{"text":"impl Freeze for WherePredicate","synthetic":true,"types":[]},{"text":"impl Freeze for PredicateType","synthetic":true,"types":[]},{"text":"impl Freeze for PredicateLifetime","synthetic":true,"types":[]},{"text":"impl Freeze for PredicateEq","synthetic":true,"types":[]},{"text":"impl Freeze for Lifetime","synthetic":true,"types":[]},{"text":"impl Freeze for Lit","synthetic":true,"types":[]},{"text":"impl Freeze for LitStr","synthetic":true,"types":[]},{"text":"impl Freeze for LitByteStr","synthetic":true,"types":[]},{"text":"impl Freeze for LitByte","synthetic":true,"types":[]},{"text":"impl Freeze for LitChar","synthetic":true,"types":[]},{"text":"impl Freeze for LitInt","synthetic":true,"types":[]},{"text":"impl Freeze for LitFloat","synthetic":true,"types":[]},{"text":"impl Freeze for LitBool","synthetic":true,"types":[]},{"text":"impl Freeze for StrStyle","synthetic":true,"types":[]},{"text":"impl Freeze for Macro","synthetic":true,"types":[]},{"text":"impl Freeze for MacroDelimiter","synthetic":true,"types":[]},{"text":"impl Freeze for DeriveInput","synthetic":true,"types":[]},{"text":"impl Freeze for Data","synthetic":true,"types":[]},{"text":"impl Freeze for DataStruct","synthetic":true,"types":[]},{"text":"impl Freeze for DataEnum","synthetic":true,"types":[]},{"text":"impl Freeze for DataUnion","synthetic":true,"types":[]},{"text":"impl Freeze for BinOp","synthetic":true,"types":[]},{"text":"impl Freeze for UnOp","synthetic":true,"types":[]},{"text":"impl Freeze for Type","synthetic":true,"types":[]},{"text":"impl Freeze for TypeArray","synthetic":true,"types":[]},{"text":"impl Freeze for TypeBareFn","synthetic":true,"types":[]},{"text":"impl Freeze for TypeGroup","synthetic":true,"types":[]},{"text":"impl Freeze for TypeImplTrait","synthetic":true,"types":[]},{"text":"impl Freeze for TypeInfer","synthetic":true,"types":[]},{"text":"impl Freeze for TypeMacro","synthetic":true,"types":[]},{"text":"impl Freeze for TypeNever","synthetic":true,"types":[]},{"text":"impl Freeze for TypeParen","synthetic":true,"types":[]},{"text":"impl Freeze for TypePath","synthetic":true,"types":[]},{"text":"impl Freeze for TypePtr","synthetic":true,"types":[]},{"text":"impl Freeze for TypeReference","synthetic":true,"types":[]},{"text":"impl Freeze for TypeSlice","synthetic":true,"types":[]},{"text":"impl Freeze for TypeTraitObject","synthetic":true,"types":[]},{"text":"impl Freeze for TypeTuple","synthetic":true,"types":[]},{"text":"impl Freeze for Abi","synthetic":true,"types":[]},{"text":"impl Freeze for BareFnArg","synthetic":true,"types":[]},{"text":"impl Freeze for Variadic","synthetic":true,"types":[]},{"text":"impl Freeze for ReturnType","synthetic":true,"types":[]},{"text":"impl Freeze for Path","synthetic":true,"types":[]},{"text":"impl Freeze for PathSegment","synthetic":true,"types":[]},{"text":"impl Freeze for PathArguments","synthetic":true,"types":[]},{"text":"impl Freeze for GenericArgument","synthetic":true,"types":[]},{"text":"impl Freeze for AngleBracketedGenericArguments","synthetic":true,"types":[]},{"text":"impl Freeze for Binding","synthetic":true,"types":[]},{"text":"impl Freeze for Constraint","synthetic":true,"types":[]},{"text":"impl Freeze for ParenthesizedGenericArguments","synthetic":true,"types":[]},{"text":"impl Freeze for QSelf","synthetic":true,"types":[]},{"text":"impl Freeze for TokenBuffer","synthetic":true,"types":[]},{"text":"impl<'a> Freeze for Cursor<'a>","synthetic":true,"types":[]},{"text":"impl<T, P> Freeze for Punctuated<T, P>","synthetic":true,"types":[]},{"text":"impl<'a, T, P> Freeze for Pairs<'a, T, P>","synthetic":true,"types":[]},{"text":"impl<'a, T, P> Freeze for PairsMut<'a, T, P>","synthetic":true,"types":[]},{"text":"impl<T, P> Freeze for IntoPairs<T, P> where
    T: Freeze, ","synthetic":true,"types":[]},{"text":"impl<T> Freeze for IntoIter<T>","synthetic":true,"types":[]},{"text":"impl<'a, T> Freeze for Iter<'a, T>","synthetic":true,"types":[]},{"text":"impl<'a, T> Freeze for IterMut<'a, T>","synthetic":true,"types":[]},{"text":"impl<T, P> Freeze for Pair<T, P> where
    P: Freeze,
    T: Freeze, ","synthetic":true,"types":[]},{"text":"impl<'a> !Freeze for Lookahead1<'a>","synthetic":true,"types":[]},{"text":"impl Freeze for Error","synthetic":true,"types":[]},{"text":"impl<'a> !Freeze for ParseBuffer<'a>","synthetic":true,"types":[]},{"text":"impl<'c, 'a> Freeze for StepCursor<'c, 'a>","synthetic":true,"types":[]},{"text":"impl Freeze for Nothing","synthetic":true,"types":[]}]; -implementors["synstructure"] = [{"text":"impl Freeze for AddBounds","synthetic":true,"types":[]},{"text":"impl Freeze for BindStyle","synthetic":true,"types":[]},{"text":"impl<'a> Freeze for BindingInfo<'a>","synthetic":true,"types":[]},{"text":"impl<'a> Freeze for VariantAst<'a>","synthetic":true,"types":[]},{"text":"impl<'a> Freeze for VariantInfo<'a>","synthetic":true,"types":[]},{"text":"impl<'a> Freeze for Structure<'a>","synthetic":true,"types":[]}]; +implementors["delog"] = [{"text":"impl Freeze for U1","synthetic":true,"types":["delog::hex::U1"]},{"text":"impl<'a, T: ?Sized, U, S> Freeze for HexStr<'a, T, U, S>","synthetic":true,"types":["delog::hex::HexStr"]},{"text":"impl Freeze for Statistics","synthetic":true,"types":["delog::logger::Statistics"]},{"text":"impl Freeze for DefaultRenderer","synthetic":true,"types":["delog::render::DefaultRenderer"]},{"text":"impl Freeze for RipgrepRenderer","synthetic":true,"types":["delog::render::RipgrepRenderer"]}]; +implementors["flexiber"] = [{"text":"impl<'a> Freeze for Decoder<'a>","synthetic":true,"types":["flexiber::decoder::Decoder"]},{"text":"impl<'a> Freeze for Encoder<'a>","synthetic":true,"types":["flexiber::encoder::Encoder"]},{"text":"impl Freeze for Error","synthetic":true,"types":["flexiber::error::Error"]},{"text":"impl Freeze for ErrorKind","synthetic":true,"types":["flexiber::error::ErrorKind"]},{"text":"impl Freeze for Length","synthetic":true,"types":["flexiber::length::Length"]},{"text":"impl Freeze for SimpleTag","synthetic":true,"types":["flexiber::simpletag::SimpleTag"]},{"text":"impl<'a> Freeze for Slice<'a>","synthetic":true,"types":["flexiber::slice::Slice"]},{"text":"impl Freeze for Class","synthetic":true,"types":["flexiber::tag::Class"]},{"text":"impl Freeze for Tag","synthetic":true,"types":["flexiber::tag::Tag"]},{"text":"impl<V, T> Freeze for TaggedValue<V, T> where
    T: Freeze,
    V: Freeze, ","synthetic":true,"types":["flexiber::tagged::TaggedValue"]}]; +implementors["log"] = [{"text":"impl Freeze for Level","synthetic":true,"types":["log::Level"]},{"text":"impl Freeze for LevelFilter","synthetic":true,"types":["log::LevelFilter"]},{"text":"impl<'a> Freeze for Record<'a>","synthetic":true,"types":["log::Record"]},{"text":"impl<'a> Freeze for RecordBuilder<'a>","synthetic":true,"types":["log::RecordBuilder"]},{"text":"impl<'a> Freeze for Metadata<'a>","synthetic":true,"types":["log::Metadata"]},{"text":"impl<'a> Freeze for MetadataBuilder<'a>","synthetic":true,"types":["log::MetadataBuilder"]},{"text":"impl Freeze for SetLoggerError","synthetic":true,"types":["log::SetLoggerError"]},{"text":"impl Freeze for ParseLevelError","synthetic":true,"types":["log::ParseLevelError"]}]; +implementors["proc_macro2"] = [{"text":"impl Freeze for IntoIter","synthetic":true,"types":["proc_macro2::token_stream::IntoIter"]},{"text":"impl Freeze for TokenStream","synthetic":true,"types":["proc_macro2::TokenStream"]},{"text":"impl Freeze for LexError","synthetic":true,"types":["proc_macro2::LexError"]},{"text":"impl Freeze for Span","synthetic":true,"types":["proc_macro2::Span"]},{"text":"impl Freeze for TokenTree","synthetic":true,"types":["proc_macro2::TokenTree"]},{"text":"impl Freeze for Group","synthetic":true,"types":["proc_macro2::Group"]},{"text":"impl Freeze for Delimiter","synthetic":true,"types":["proc_macro2::Delimiter"]},{"text":"impl Freeze for Punct","synthetic":true,"types":["proc_macro2::Punct"]},{"text":"impl Freeze for Spacing","synthetic":true,"types":["proc_macro2::Spacing"]},{"text":"impl Freeze for Ident","synthetic":true,"types":["proc_macro2::Ident"]},{"text":"impl Freeze for Literal","synthetic":true,"types":["proc_macro2::Literal"]}]; +implementors["syn"] = [{"text":"impl Freeze for Underscore","synthetic":true,"types":["syn::token::Underscore"]},{"text":"impl Freeze for Abstract","synthetic":true,"types":["syn::token::Abstract"]},{"text":"impl Freeze for As","synthetic":true,"types":["syn::token::As"]},{"text":"impl Freeze for Async","synthetic":true,"types":["syn::token::Async"]},{"text":"impl Freeze for Auto","synthetic":true,"types":["syn::token::Auto"]},{"text":"impl Freeze for Await","synthetic":true,"types":["syn::token::Await"]},{"text":"impl Freeze for Become","synthetic":true,"types":["syn::token::Become"]},{"text":"impl Freeze for Box","synthetic":true,"types":["syn::token::Box"]},{"text":"impl Freeze for Break","synthetic":true,"types":["syn::token::Break"]},{"text":"impl Freeze for Const","synthetic":true,"types":["syn::token::Const"]},{"text":"impl Freeze for Continue","synthetic":true,"types":["syn::token::Continue"]},{"text":"impl Freeze for Crate","synthetic":true,"types":["syn::token::Crate"]},{"text":"impl Freeze for Default","synthetic":true,"types":["syn::token::Default"]},{"text":"impl Freeze for Do","synthetic":true,"types":["syn::token::Do"]},{"text":"impl Freeze for Dyn","synthetic":true,"types":["syn::token::Dyn"]},{"text":"impl Freeze for Else","synthetic":true,"types":["syn::token::Else"]},{"text":"impl Freeze for Enum","synthetic":true,"types":["syn::token::Enum"]},{"text":"impl Freeze for Extern","synthetic":true,"types":["syn::token::Extern"]},{"text":"impl Freeze for Final","synthetic":true,"types":["syn::token::Final"]},{"text":"impl Freeze for Fn","synthetic":true,"types":["syn::token::Fn"]},{"text":"impl Freeze for For","synthetic":true,"types":["syn::token::For"]},{"text":"impl Freeze for If","synthetic":true,"types":["syn::token::If"]},{"text":"impl Freeze for Impl","synthetic":true,"types":["syn::token::Impl"]},{"text":"impl Freeze for In","synthetic":true,"types":["syn::token::In"]},{"text":"impl Freeze for Let","synthetic":true,"types":["syn::token::Let"]},{"text":"impl Freeze for Loop","synthetic":true,"types":["syn::token::Loop"]},{"text":"impl Freeze for Macro","synthetic":true,"types":["syn::token::Macro"]},{"text":"impl Freeze for Match","synthetic":true,"types":["syn::token::Match"]},{"text":"impl Freeze for Mod","synthetic":true,"types":["syn::token::Mod"]},{"text":"impl Freeze for Move","synthetic":true,"types":["syn::token::Move"]},{"text":"impl Freeze for Mut","synthetic":true,"types":["syn::token::Mut"]},{"text":"impl Freeze for Override","synthetic":true,"types":["syn::token::Override"]},{"text":"impl Freeze for Priv","synthetic":true,"types":["syn::token::Priv"]},{"text":"impl Freeze for Pub","synthetic":true,"types":["syn::token::Pub"]},{"text":"impl Freeze for Ref","synthetic":true,"types":["syn::token::Ref"]},{"text":"impl Freeze for Return","synthetic":true,"types":["syn::token::Return"]},{"text":"impl Freeze for SelfType","synthetic":true,"types":["syn::token::SelfType"]},{"text":"impl Freeze for SelfValue","synthetic":true,"types":["syn::token::SelfValue"]},{"text":"impl Freeze for Static","synthetic":true,"types":["syn::token::Static"]},{"text":"impl Freeze for Struct","synthetic":true,"types":["syn::token::Struct"]},{"text":"impl Freeze for Super","synthetic":true,"types":["syn::token::Super"]},{"text":"impl Freeze for Trait","synthetic":true,"types":["syn::token::Trait"]},{"text":"impl Freeze for Try","synthetic":true,"types":["syn::token::Try"]},{"text":"impl Freeze for Type","synthetic":true,"types":["syn::token::Type"]},{"text":"impl Freeze for Typeof","synthetic":true,"types":["syn::token::Typeof"]},{"text":"impl Freeze for Union","synthetic":true,"types":["syn::token::Union"]},{"text":"impl Freeze for Unsafe","synthetic":true,"types":["syn::token::Unsafe"]},{"text":"impl Freeze for Unsized","synthetic":true,"types":["syn::token::Unsized"]},{"text":"impl Freeze for Use","synthetic":true,"types":["syn::token::Use"]},{"text":"impl Freeze for Virtual","synthetic":true,"types":["syn::token::Virtual"]},{"text":"impl Freeze for Where","synthetic":true,"types":["syn::token::Where"]},{"text":"impl Freeze for While","synthetic":true,"types":["syn::token::While"]},{"text":"impl Freeze for Yield","synthetic":true,"types":["syn::token::Yield"]},{"text":"impl Freeze for Add","synthetic":true,"types":["syn::token::Add"]},{"text":"impl Freeze for AddEq","synthetic":true,"types":["syn::token::AddEq"]},{"text":"impl Freeze for And","synthetic":true,"types":["syn::token::And"]},{"text":"impl Freeze for AndAnd","synthetic":true,"types":["syn::token::AndAnd"]},{"text":"impl Freeze for AndEq","synthetic":true,"types":["syn::token::AndEq"]},{"text":"impl Freeze for At","synthetic":true,"types":["syn::token::At"]},{"text":"impl Freeze for Bang","synthetic":true,"types":["syn::token::Bang"]},{"text":"impl Freeze for Caret","synthetic":true,"types":["syn::token::Caret"]},{"text":"impl Freeze for CaretEq","synthetic":true,"types":["syn::token::CaretEq"]},{"text":"impl Freeze for Colon","synthetic":true,"types":["syn::token::Colon"]},{"text":"impl Freeze for Colon2","synthetic":true,"types":["syn::token::Colon2"]},{"text":"impl Freeze for Comma","synthetic":true,"types":["syn::token::Comma"]},{"text":"impl Freeze for Div","synthetic":true,"types":["syn::token::Div"]},{"text":"impl Freeze for DivEq","synthetic":true,"types":["syn::token::DivEq"]},{"text":"impl Freeze for Dollar","synthetic":true,"types":["syn::token::Dollar"]},{"text":"impl Freeze for Dot","synthetic":true,"types":["syn::token::Dot"]},{"text":"impl Freeze for Dot2","synthetic":true,"types":["syn::token::Dot2"]},{"text":"impl Freeze for Dot3","synthetic":true,"types":["syn::token::Dot3"]},{"text":"impl Freeze for DotDotEq","synthetic":true,"types":["syn::token::DotDotEq"]},{"text":"impl Freeze for Eq","synthetic":true,"types":["syn::token::Eq"]},{"text":"impl Freeze for EqEq","synthetic":true,"types":["syn::token::EqEq"]},{"text":"impl Freeze for Ge","synthetic":true,"types":["syn::token::Ge"]},{"text":"impl Freeze for Gt","synthetic":true,"types":["syn::token::Gt"]},{"text":"impl Freeze for Le","synthetic":true,"types":["syn::token::Le"]},{"text":"impl Freeze for Lt","synthetic":true,"types":["syn::token::Lt"]},{"text":"impl Freeze for MulEq","synthetic":true,"types":["syn::token::MulEq"]},{"text":"impl Freeze for Ne","synthetic":true,"types":["syn::token::Ne"]},{"text":"impl Freeze for Or","synthetic":true,"types":["syn::token::Or"]},{"text":"impl Freeze for OrEq","synthetic":true,"types":["syn::token::OrEq"]},{"text":"impl Freeze for OrOr","synthetic":true,"types":["syn::token::OrOr"]},{"text":"impl Freeze for Pound","synthetic":true,"types":["syn::token::Pound"]},{"text":"impl Freeze for Question","synthetic":true,"types":["syn::token::Question"]},{"text":"impl Freeze for RArrow","synthetic":true,"types":["syn::token::RArrow"]},{"text":"impl Freeze for LArrow","synthetic":true,"types":["syn::token::LArrow"]},{"text":"impl Freeze for Rem","synthetic":true,"types":["syn::token::Rem"]},{"text":"impl Freeze for RemEq","synthetic":true,"types":["syn::token::RemEq"]},{"text":"impl Freeze for FatArrow","synthetic":true,"types":["syn::token::FatArrow"]},{"text":"impl Freeze for Semi","synthetic":true,"types":["syn::token::Semi"]},{"text":"impl Freeze for Shl","synthetic":true,"types":["syn::token::Shl"]},{"text":"impl Freeze for ShlEq","synthetic":true,"types":["syn::token::ShlEq"]},{"text":"impl Freeze for Shr","synthetic":true,"types":["syn::token::Shr"]},{"text":"impl Freeze for ShrEq","synthetic":true,"types":["syn::token::ShrEq"]},{"text":"impl Freeze for Star","synthetic":true,"types":["syn::token::Star"]},{"text":"impl Freeze for Sub","synthetic":true,"types":["syn::token::Sub"]},{"text":"impl Freeze for SubEq","synthetic":true,"types":["syn::token::SubEq"]},{"text":"impl Freeze for Tilde","synthetic":true,"types":["syn::token::Tilde"]},{"text":"impl Freeze for Brace","synthetic":true,"types":["syn::token::Brace"]},{"text":"impl Freeze for Bracket","synthetic":true,"types":["syn::token::Bracket"]},{"text":"impl Freeze for Paren","synthetic":true,"types":["syn::token::Paren"]},{"text":"impl Freeze for Group","synthetic":true,"types":["syn::token::Group"]},{"text":"impl Freeze for Attribute","synthetic":true,"types":["syn::attr::Attribute"]},{"text":"impl Freeze for AttrStyle","synthetic":true,"types":["syn::attr::AttrStyle"]},{"text":"impl Freeze for Meta","synthetic":true,"types":["syn::attr::Meta"]},{"text":"impl Freeze for MetaList","synthetic":true,"types":["syn::attr::MetaList"]},{"text":"impl Freeze for MetaNameValue","synthetic":true,"types":["syn::attr::MetaNameValue"]},{"text":"impl Freeze for NestedMeta","synthetic":true,"types":["syn::attr::NestedMeta"]},{"text":"impl Freeze for Variant","synthetic":true,"types":["syn::data::Variant"]},{"text":"impl Freeze for Fields","synthetic":true,"types":["syn::data::Fields"]},{"text":"impl Freeze for FieldsNamed","synthetic":true,"types":["syn::data::FieldsNamed"]},{"text":"impl Freeze for FieldsUnnamed","synthetic":true,"types":["syn::data::FieldsUnnamed"]},{"text":"impl Freeze for Field","synthetic":true,"types":["syn::data::Field"]},{"text":"impl Freeze for Visibility","synthetic":true,"types":["syn::data::Visibility"]},{"text":"impl Freeze for VisPublic","synthetic":true,"types":["syn::data::VisPublic"]},{"text":"impl Freeze for VisCrate","synthetic":true,"types":["syn::data::VisCrate"]},{"text":"impl Freeze for VisRestricted","synthetic":true,"types":["syn::data::VisRestricted"]},{"text":"impl Freeze for Expr","synthetic":true,"types":["syn::expr::Expr"]},{"text":"impl Freeze for ExprArray","synthetic":true,"types":["syn::expr::ExprArray"]},{"text":"impl Freeze for ExprAssign","synthetic":true,"types":["syn::expr::ExprAssign"]},{"text":"impl Freeze for ExprAssignOp","synthetic":true,"types":["syn::expr::ExprAssignOp"]},{"text":"impl Freeze for ExprAsync","synthetic":true,"types":["syn::expr::ExprAsync"]},{"text":"impl Freeze for ExprAwait","synthetic":true,"types":["syn::expr::ExprAwait"]},{"text":"impl Freeze for ExprBinary","synthetic":true,"types":["syn::expr::ExprBinary"]},{"text":"impl Freeze for ExprBlock","synthetic":true,"types":["syn::expr::ExprBlock"]},{"text":"impl Freeze for ExprBox","synthetic":true,"types":["syn::expr::ExprBox"]},{"text":"impl Freeze for ExprBreak","synthetic":true,"types":["syn::expr::ExprBreak"]},{"text":"impl Freeze for ExprCall","synthetic":true,"types":["syn::expr::ExprCall"]},{"text":"impl Freeze for ExprCast","synthetic":true,"types":["syn::expr::ExprCast"]},{"text":"impl Freeze for ExprClosure","synthetic":true,"types":["syn::expr::ExprClosure"]},{"text":"impl Freeze for ExprContinue","synthetic":true,"types":["syn::expr::ExprContinue"]},{"text":"impl Freeze for ExprField","synthetic":true,"types":["syn::expr::ExprField"]},{"text":"impl Freeze for ExprForLoop","synthetic":true,"types":["syn::expr::ExprForLoop"]},{"text":"impl Freeze for ExprGroup","synthetic":true,"types":["syn::expr::ExprGroup"]},{"text":"impl Freeze for ExprIf","synthetic":true,"types":["syn::expr::ExprIf"]},{"text":"impl Freeze for ExprIndex","synthetic":true,"types":["syn::expr::ExprIndex"]},{"text":"impl Freeze for ExprLet","synthetic":true,"types":["syn::expr::ExprLet"]},{"text":"impl Freeze for ExprLit","synthetic":true,"types":["syn::expr::ExprLit"]},{"text":"impl Freeze for ExprLoop","synthetic":true,"types":["syn::expr::ExprLoop"]},{"text":"impl Freeze for ExprMacro","synthetic":true,"types":["syn::expr::ExprMacro"]},{"text":"impl Freeze for ExprMatch","synthetic":true,"types":["syn::expr::ExprMatch"]},{"text":"impl Freeze for ExprMethodCall","synthetic":true,"types":["syn::expr::ExprMethodCall"]},{"text":"impl Freeze for ExprParen","synthetic":true,"types":["syn::expr::ExprParen"]},{"text":"impl Freeze for ExprPath","synthetic":true,"types":["syn::expr::ExprPath"]},{"text":"impl Freeze for ExprRange","synthetic":true,"types":["syn::expr::ExprRange"]},{"text":"impl Freeze for ExprReference","synthetic":true,"types":["syn::expr::ExprReference"]},{"text":"impl Freeze for ExprRepeat","synthetic":true,"types":["syn::expr::ExprRepeat"]},{"text":"impl Freeze for ExprReturn","synthetic":true,"types":["syn::expr::ExprReturn"]},{"text":"impl Freeze for ExprStruct","synthetic":true,"types":["syn::expr::ExprStruct"]},{"text":"impl Freeze for ExprTry","synthetic":true,"types":["syn::expr::ExprTry"]},{"text":"impl Freeze for ExprTryBlock","synthetic":true,"types":["syn::expr::ExprTryBlock"]},{"text":"impl Freeze for ExprTuple","synthetic":true,"types":["syn::expr::ExprTuple"]},{"text":"impl Freeze for ExprType","synthetic":true,"types":["syn::expr::ExprType"]},{"text":"impl Freeze for ExprUnary","synthetic":true,"types":["syn::expr::ExprUnary"]},{"text":"impl Freeze for ExprUnsafe","synthetic":true,"types":["syn::expr::ExprUnsafe"]},{"text":"impl Freeze for ExprWhile","synthetic":true,"types":["syn::expr::ExprWhile"]},{"text":"impl Freeze for ExprYield","synthetic":true,"types":["syn::expr::ExprYield"]},{"text":"impl Freeze for Member","synthetic":true,"types":["syn::expr::Member"]},{"text":"impl Freeze for Index","synthetic":true,"types":["syn::expr::Index"]},{"text":"impl Freeze for Generics","synthetic":true,"types":["syn::generics::Generics"]},{"text":"impl Freeze for GenericParam","synthetic":true,"types":["syn::generics::GenericParam"]},{"text":"impl Freeze for TypeParam","synthetic":true,"types":["syn::generics::TypeParam"]},{"text":"impl Freeze for LifetimeDef","synthetic":true,"types":["syn::generics::LifetimeDef"]},{"text":"impl Freeze for ConstParam","synthetic":true,"types":["syn::generics::ConstParam"]},{"text":"impl<'a> Freeze for ImplGenerics<'a>","synthetic":true,"types":["syn::generics::ImplGenerics"]},{"text":"impl<'a> Freeze for TypeGenerics<'a>","synthetic":true,"types":["syn::generics::TypeGenerics"]},{"text":"impl<'a> Freeze for Turbofish<'a>","synthetic":true,"types":["syn::generics::Turbofish"]},{"text":"impl Freeze for BoundLifetimes","synthetic":true,"types":["syn::generics::BoundLifetimes"]},{"text":"impl Freeze for TypeParamBound","synthetic":true,"types":["syn::generics::TypeParamBound"]},{"text":"impl Freeze for TraitBound","synthetic":true,"types":["syn::generics::TraitBound"]},{"text":"impl Freeze for TraitBoundModifier","synthetic":true,"types":["syn::generics::TraitBoundModifier"]},{"text":"impl Freeze for WhereClause","synthetic":true,"types":["syn::generics::WhereClause"]},{"text":"impl Freeze for WherePredicate","synthetic":true,"types":["syn::generics::WherePredicate"]},{"text":"impl Freeze for PredicateType","synthetic":true,"types":["syn::generics::PredicateType"]},{"text":"impl Freeze for PredicateLifetime","synthetic":true,"types":["syn::generics::PredicateLifetime"]},{"text":"impl Freeze for PredicateEq","synthetic":true,"types":["syn::generics::PredicateEq"]},{"text":"impl Freeze for Lifetime","synthetic":true,"types":["syn::lifetime::Lifetime"]},{"text":"impl Freeze for Lit","synthetic":true,"types":["syn::lit::Lit"]},{"text":"impl Freeze for LitStr","synthetic":true,"types":["syn::lit::LitStr"]},{"text":"impl Freeze for LitByteStr","synthetic":true,"types":["syn::lit::LitByteStr"]},{"text":"impl Freeze for LitByte","synthetic":true,"types":["syn::lit::LitByte"]},{"text":"impl Freeze for LitChar","synthetic":true,"types":["syn::lit::LitChar"]},{"text":"impl Freeze for LitInt","synthetic":true,"types":["syn::lit::LitInt"]},{"text":"impl Freeze for LitFloat","synthetic":true,"types":["syn::lit::LitFloat"]},{"text":"impl Freeze for LitBool","synthetic":true,"types":["syn::lit::LitBool"]},{"text":"impl Freeze for StrStyle","synthetic":true,"types":["syn::lit::StrStyle"]},{"text":"impl Freeze for Macro","synthetic":true,"types":["syn::mac::Macro"]},{"text":"impl Freeze for MacroDelimiter","synthetic":true,"types":["syn::mac::MacroDelimiter"]},{"text":"impl Freeze for DeriveInput","synthetic":true,"types":["syn::derive::DeriveInput"]},{"text":"impl Freeze for Data","synthetic":true,"types":["syn::derive::Data"]},{"text":"impl Freeze for DataStruct","synthetic":true,"types":["syn::derive::DataStruct"]},{"text":"impl Freeze for DataEnum","synthetic":true,"types":["syn::derive::DataEnum"]},{"text":"impl Freeze for DataUnion","synthetic":true,"types":["syn::derive::DataUnion"]},{"text":"impl Freeze for BinOp","synthetic":true,"types":["syn::op::BinOp"]},{"text":"impl Freeze for UnOp","synthetic":true,"types":["syn::op::UnOp"]},{"text":"impl Freeze for Type","synthetic":true,"types":["syn::ty::Type"]},{"text":"impl Freeze for TypeArray","synthetic":true,"types":["syn::ty::TypeArray"]},{"text":"impl Freeze for TypeBareFn","synthetic":true,"types":["syn::ty::TypeBareFn"]},{"text":"impl Freeze for TypeGroup","synthetic":true,"types":["syn::ty::TypeGroup"]},{"text":"impl Freeze for TypeImplTrait","synthetic":true,"types":["syn::ty::TypeImplTrait"]},{"text":"impl Freeze for TypeInfer","synthetic":true,"types":["syn::ty::TypeInfer"]},{"text":"impl Freeze for TypeMacro","synthetic":true,"types":["syn::ty::TypeMacro"]},{"text":"impl Freeze for TypeNever","synthetic":true,"types":["syn::ty::TypeNever"]},{"text":"impl Freeze for TypeParen","synthetic":true,"types":["syn::ty::TypeParen"]},{"text":"impl Freeze for TypePath","synthetic":true,"types":["syn::ty::TypePath"]},{"text":"impl Freeze for TypePtr","synthetic":true,"types":["syn::ty::TypePtr"]},{"text":"impl Freeze for TypeReference","synthetic":true,"types":["syn::ty::TypeReference"]},{"text":"impl Freeze for TypeSlice","synthetic":true,"types":["syn::ty::TypeSlice"]},{"text":"impl Freeze for TypeTraitObject","synthetic":true,"types":["syn::ty::TypeTraitObject"]},{"text":"impl Freeze for TypeTuple","synthetic":true,"types":["syn::ty::TypeTuple"]},{"text":"impl Freeze for Abi","synthetic":true,"types":["syn::ty::Abi"]},{"text":"impl Freeze for BareFnArg","synthetic":true,"types":["syn::ty::BareFnArg"]},{"text":"impl Freeze for Variadic","synthetic":true,"types":["syn::ty::Variadic"]},{"text":"impl Freeze for ReturnType","synthetic":true,"types":["syn::ty::ReturnType"]},{"text":"impl Freeze for Path","synthetic":true,"types":["syn::path::Path"]},{"text":"impl Freeze for PathSegment","synthetic":true,"types":["syn::path::PathSegment"]},{"text":"impl Freeze for PathArguments","synthetic":true,"types":["syn::path::PathArguments"]},{"text":"impl Freeze for GenericArgument","synthetic":true,"types":["syn::path::GenericArgument"]},{"text":"impl Freeze for AngleBracketedGenericArguments","synthetic":true,"types":["syn::path::AngleBracketedGenericArguments"]},{"text":"impl Freeze for Binding","synthetic":true,"types":["syn::path::Binding"]},{"text":"impl Freeze for Constraint","synthetic":true,"types":["syn::path::Constraint"]},{"text":"impl Freeze for ParenthesizedGenericArguments","synthetic":true,"types":["syn::path::ParenthesizedGenericArguments"]},{"text":"impl Freeze for QSelf","synthetic":true,"types":["syn::path::QSelf"]},{"text":"impl Freeze for TokenBuffer","synthetic":true,"types":["syn::buffer::TokenBuffer"]},{"text":"impl<'a> Freeze for Cursor<'a>","synthetic":true,"types":["syn::buffer::Cursor"]},{"text":"impl<T, P> Freeze for Punctuated<T, P>","synthetic":true,"types":["syn::punctuated::Punctuated"]},{"text":"impl<'a, T, P> Freeze for Pairs<'a, T, P>","synthetic":true,"types":["syn::punctuated::Pairs"]},{"text":"impl<'a, T, P> Freeze for PairsMut<'a, T, P>","synthetic":true,"types":["syn::punctuated::PairsMut"]},{"text":"impl<T, P> Freeze for IntoPairs<T, P> where
    T: Freeze, ","synthetic":true,"types":["syn::punctuated::IntoPairs"]},{"text":"impl<T> Freeze for IntoIter<T>","synthetic":true,"types":["syn::punctuated::IntoIter"]},{"text":"impl<'a, T> Freeze for Iter<'a, T>","synthetic":true,"types":["syn::punctuated::Iter"]},{"text":"impl<'a, T> Freeze for IterMut<'a, T>","synthetic":true,"types":["syn::punctuated::IterMut"]},{"text":"impl<T, P> Freeze for Pair<T, P> where
    P: Freeze,
    T: Freeze, ","synthetic":true,"types":["syn::punctuated::Pair"]},{"text":"impl<'a> !Freeze for Lookahead1<'a>","synthetic":true,"types":["syn::lookahead::Lookahead1"]},{"text":"impl Freeze for Error","synthetic":true,"types":["syn::error::Error"]},{"text":"impl<'a> !Freeze for ParseBuffer<'a>","synthetic":true,"types":["syn::parse::ParseBuffer"]},{"text":"impl<'c, 'a> Freeze for StepCursor<'c, 'a>","synthetic":true,"types":["syn::parse::StepCursor"]},{"text":"impl Freeze for Nothing","synthetic":true,"types":["syn::parse::Nothing"]}]; +implementors["synstructure"] = [{"text":"impl Freeze for AddBounds","synthetic":true,"types":["synstructure::AddBounds"]},{"text":"impl Freeze for BindStyle","synthetic":true,"types":["synstructure::BindStyle"]},{"text":"impl<'a> Freeze for BindingInfo<'a>","synthetic":true,"types":["synstructure::BindingInfo"]},{"text":"impl<'a> Freeze for VariantAst<'a>","synthetic":true,"types":["synstructure::VariantAst"]},{"text":"impl<'a> Freeze for VariantInfo<'a>","synthetic":true,"types":["synstructure::VariantInfo"]},{"text":"impl<'a> Freeze for Structure<'a>","synthetic":true,"types":["synstructure::Structure"]}]; if (window.register_implementors) {window.register_implementors(implementors);} else {window.pending_implementors = implementors;}})() \ No newline at end of file diff --git a/implementors/core/marker/trait.Send.js b/implementors/core/marker/trait.Send.js index cdf1562..cf18b75 100644 --- a/implementors/core/marker/trait.Send.js +++ b/implementors/core/marker/trait.Send.js @@ -1,8 +1,8 @@ (function() {var implementors = {}; -implementors["delog"] = [{"text":"impl Send for U1","synthetic":true,"types":[]},{"text":"impl<'a, T: ?Sized, U, S> Send for HexStr<'a, T, U, S> where
    S: Send,
    T: Sync,
    U: Send, ","synthetic":true,"types":[]},{"text":"impl Send for Statistics","synthetic":true,"types":[]},{"text":"impl Send for RipgrepRenderer","synthetic":true,"types":[]},{"text":"impl Send for DefaultRenderer","synthetic":false,"types":[]}]; -implementors["flexiber"] = [{"text":"impl<'a> Send for Decoder<'a>","synthetic":true,"types":[]},{"text":"impl<'a> Send for Encoder<'a>","synthetic":true,"types":[]},{"text":"impl Send for Error","synthetic":true,"types":[]},{"text":"impl Send for ErrorKind","synthetic":true,"types":[]},{"text":"impl Send for Length","synthetic":true,"types":[]},{"text":"impl Send for SimpleTag","synthetic":true,"types":[]},{"text":"impl<'a> Send for Slice<'a>","synthetic":true,"types":[]},{"text":"impl Send for Class","synthetic":true,"types":[]},{"text":"impl Send for Tag","synthetic":true,"types":[]},{"text":"impl<V, T> Send for TaggedValue<V, T> where
    T: Send,
    V: Send, ","synthetic":true,"types":[]}]; -implementors["log"] = [{"text":"impl Send for Level","synthetic":true,"types":[]},{"text":"impl Send for LevelFilter","synthetic":true,"types":[]},{"text":"impl<'a> !Send for Record<'a>","synthetic":true,"types":[]},{"text":"impl<'a> !Send for RecordBuilder<'a>","synthetic":true,"types":[]},{"text":"impl<'a> Send for Metadata<'a>","synthetic":true,"types":[]},{"text":"impl<'a> Send for MetadataBuilder<'a>","synthetic":true,"types":[]},{"text":"impl Send for SetLoggerError","synthetic":true,"types":[]},{"text":"impl Send for ParseLevelError","synthetic":true,"types":[]}]; -implementors["proc_macro2"] = [{"text":"impl !Send for IntoIter","synthetic":true,"types":[]},{"text":"impl !Send for TokenStream","synthetic":true,"types":[]},{"text":"impl !Send for LexError","synthetic":true,"types":[]},{"text":"impl !Send for Span","synthetic":true,"types":[]},{"text":"impl !Send for TokenTree","synthetic":true,"types":[]},{"text":"impl !Send for Group","synthetic":true,"types":[]},{"text":"impl Send for Delimiter","synthetic":true,"types":[]},{"text":"impl !Send for Punct","synthetic":true,"types":[]},{"text":"impl Send for Spacing","synthetic":true,"types":[]},{"text":"impl !Send for Ident","synthetic":true,"types":[]},{"text":"impl !Send for Literal","synthetic":true,"types":[]}]; -implementors["syn"] = [{"text":"impl !Send for Underscore","synthetic":true,"types":[]},{"text":"impl !Send for Abstract","synthetic":true,"types":[]},{"text":"impl !Send for As","synthetic":true,"types":[]},{"text":"impl !Send for Async","synthetic":true,"types":[]},{"text":"impl !Send for Auto","synthetic":true,"types":[]},{"text":"impl !Send for Await","synthetic":true,"types":[]},{"text":"impl !Send for Become","synthetic":true,"types":[]},{"text":"impl !Send for Box","synthetic":true,"types":[]},{"text":"impl !Send for Break","synthetic":true,"types":[]},{"text":"impl !Send for Const","synthetic":true,"types":[]},{"text":"impl !Send for Continue","synthetic":true,"types":[]},{"text":"impl !Send for Crate","synthetic":true,"types":[]},{"text":"impl !Send for Default","synthetic":true,"types":[]},{"text":"impl !Send for Do","synthetic":true,"types":[]},{"text":"impl !Send for Dyn","synthetic":true,"types":[]},{"text":"impl !Send for Else","synthetic":true,"types":[]},{"text":"impl !Send for Enum","synthetic":true,"types":[]},{"text":"impl !Send for Extern","synthetic":true,"types":[]},{"text":"impl !Send for Final","synthetic":true,"types":[]},{"text":"impl !Send for Fn","synthetic":true,"types":[]},{"text":"impl !Send for For","synthetic":true,"types":[]},{"text":"impl !Send for If","synthetic":true,"types":[]},{"text":"impl !Send for Impl","synthetic":true,"types":[]},{"text":"impl !Send for In","synthetic":true,"types":[]},{"text":"impl !Send for Let","synthetic":true,"types":[]},{"text":"impl !Send for Loop","synthetic":true,"types":[]},{"text":"impl !Send for Macro","synthetic":true,"types":[]},{"text":"impl !Send for Match","synthetic":true,"types":[]},{"text":"impl !Send for Mod","synthetic":true,"types":[]},{"text":"impl !Send for Move","synthetic":true,"types":[]},{"text":"impl !Send for Mut","synthetic":true,"types":[]},{"text":"impl !Send for Override","synthetic":true,"types":[]},{"text":"impl !Send for Priv","synthetic":true,"types":[]},{"text":"impl !Send for Pub","synthetic":true,"types":[]},{"text":"impl !Send for Ref","synthetic":true,"types":[]},{"text":"impl !Send for Return","synthetic":true,"types":[]},{"text":"impl !Send for SelfType","synthetic":true,"types":[]},{"text":"impl !Send for SelfValue","synthetic":true,"types":[]},{"text":"impl !Send for Static","synthetic":true,"types":[]},{"text":"impl !Send for Struct","synthetic":true,"types":[]},{"text":"impl !Send for Super","synthetic":true,"types":[]},{"text":"impl !Send for Trait","synthetic":true,"types":[]},{"text":"impl !Send for Try","synthetic":true,"types":[]},{"text":"impl !Send for Type","synthetic":true,"types":[]},{"text":"impl !Send for Typeof","synthetic":true,"types":[]},{"text":"impl !Send for Union","synthetic":true,"types":[]},{"text":"impl !Send for Unsafe","synthetic":true,"types":[]},{"text":"impl !Send for Unsized","synthetic":true,"types":[]},{"text":"impl !Send for Use","synthetic":true,"types":[]},{"text":"impl !Send for Virtual","synthetic":true,"types":[]},{"text":"impl !Send for Where","synthetic":true,"types":[]},{"text":"impl !Send for While","synthetic":true,"types":[]},{"text":"impl !Send for Yield","synthetic":true,"types":[]},{"text":"impl !Send for Add","synthetic":true,"types":[]},{"text":"impl !Send for AddEq","synthetic":true,"types":[]},{"text":"impl !Send for And","synthetic":true,"types":[]},{"text":"impl !Send for AndAnd","synthetic":true,"types":[]},{"text":"impl !Send for AndEq","synthetic":true,"types":[]},{"text":"impl !Send for At","synthetic":true,"types":[]},{"text":"impl !Send for Bang","synthetic":true,"types":[]},{"text":"impl !Send for Caret","synthetic":true,"types":[]},{"text":"impl !Send for CaretEq","synthetic":true,"types":[]},{"text":"impl !Send for Colon","synthetic":true,"types":[]},{"text":"impl !Send for Colon2","synthetic":true,"types":[]},{"text":"impl !Send for Comma","synthetic":true,"types":[]},{"text":"impl !Send for Div","synthetic":true,"types":[]},{"text":"impl !Send for DivEq","synthetic":true,"types":[]},{"text":"impl !Send for Dollar","synthetic":true,"types":[]},{"text":"impl !Send for Dot","synthetic":true,"types":[]},{"text":"impl !Send for Dot2","synthetic":true,"types":[]},{"text":"impl !Send for Dot3","synthetic":true,"types":[]},{"text":"impl !Send for DotDotEq","synthetic":true,"types":[]},{"text":"impl !Send for Eq","synthetic":true,"types":[]},{"text":"impl !Send for EqEq","synthetic":true,"types":[]},{"text":"impl !Send for Ge","synthetic":true,"types":[]},{"text":"impl !Send for Gt","synthetic":true,"types":[]},{"text":"impl !Send for Le","synthetic":true,"types":[]},{"text":"impl !Send for Lt","synthetic":true,"types":[]},{"text":"impl !Send for MulEq","synthetic":true,"types":[]},{"text":"impl !Send for Ne","synthetic":true,"types":[]},{"text":"impl !Send for Or","synthetic":true,"types":[]},{"text":"impl !Send for OrEq","synthetic":true,"types":[]},{"text":"impl !Send for OrOr","synthetic":true,"types":[]},{"text":"impl !Send for Pound","synthetic":true,"types":[]},{"text":"impl !Send for Question","synthetic":true,"types":[]},{"text":"impl !Send for RArrow","synthetic":true,"types":[]},{"text":"impl !Send for LArrow","synthetic":true,"types":[]},{"text":"impl !Send for Rem","synthetic":true,"types":[]},{"text":"impl !Send for RemEq","synthetic":true,"types":[]},{"text":"impl !Send for FatArrow","synthetic":true,"types":[]},{"text":"impl !Send for Semi","synthetic":true,"types":[]},{"text":"impl !Send for Shl","synthetic":true,"types":[]},{"text":"impl !Send for ShlEq","synthetic":true,"types":[]},{"text":"impl !Send for Shr","synthetic":true,"types":[]},{"text":"impl !Send for ShrEq","synthetic":true,"types":[]},{"text":"impl !Send for Star","synthetic":true,"types":[]},{"text":"impl !Send for Sub","synthetic":true,"types":[]},{"text":"impl !Send for SubEq","synthetic":true,"types":[]},{"text":"impl !Send for Tilde","synthetic":true,"types":[]},{"text":"impl !Send for Brace","synthetic":true,"types":[]},{"text":"impl !Send for Bracket","synthetic":true,"types":[]},{"text":"impl !Send for Paren","synthetic":true,"types":[]},{"text":"impl !Send for Group","synthetic":true,"types":[]},{"text":"impl !Send for Attribute","synthetic":true,"types":[]},{"text":"impl !Send for AttrStyle","synthetic":true,"types":[]},{"text":"impl !Send for Meta","synthetic":true,"types":[]},{"text":"impl !Send for MetaList","synthetic":true,"types":[]},{"text":"impl !Send for MetaNameValue","synthetic":true,"types":[]},{"text":"impl !Send for NestedMeta","synthetic":true,"types":[]},{"text":"impl !Send for Variant","synthetic":true,"types":[]},{"text":"impl !Send for Fields","synthetic":true,"types":[]},{"text":"impl !Send for FieldsNamed","synthetic":true,"types":[]},{"text":"impl !Send for FieldsUnnamed","synthetic":true,"types":[]},{"text":"impl !Send for Field","synthetic":true,"types":[]},{"text":"impl !Send for Visibility","synthetic":true,"types":[]},{"text":"impl !Send for VisPublic","synthetic":true,"types":[]},{"text":"impl !Send for VisCrate","synthetic":true,"types":[]},{"text":"impl !Send for VisRestricted","synthetic":true,"types":[]},{"text":"impl !Send for Expr","synthetic":true,"types":[]},{"text":"impl !Send for ExprArray","synthetic":true,"types":[]},{"text":"impl !Send for ExprAssign","synthetic":true,"types":[]},{"text":"impl !Send for ExprAssignOp","synthetic":true,"types":[]},{"text":"impl !Send for ExprAsync","synthetic":true,"types":[]},{"text":"impl !Send for ExprAwait","synthetic":true,"types":[]},{"text":"impl !Send for ExprBinary","synthetic":true,"types":[]},{"text":"impl !Send for ExprBlock","synthetic":true,"types":[]},{"text":"impl !Send for ExprBox","synthetic":true,"types":[]},{"text":"impl !Send for ExprBreak","synthetic":true,"types":[]},{"text":"impl !Send for ExprCall","synthetic":true,"types":[]},{"text":"impl !Send for ExprCast","synthetic":true,"types":[]},{"text":"impl !Send for ExprClosure","synthetic":true,"types":[]},{"text":"impl !Send for ExprContinue","synthetic":true,"types":[]},{"text":"impl !Send for ExprField","synthetic":true,"types":[]},{"text":"impl !Send for ExprForLoop","synthetic":true,"types":[]},{"text":"impl !Send for ExprGroup","synthetic":true,"types":[]},{"text":"impl !Send for ExprIf","synthetic":true,"types":[]},{"text":"impl !Send for ExprIndex","synthetic":true,"types":[]},{"text":"impl !Send for ExprLet","synthetic":true,"types":[]},{"text":"impl !Send for ExprLit","synthetic":true,"types":[]},{"text":"impl !Send for ExprLoop","synthetic":true,"types":[]},{"text":"impl !Send for ExprMacro","synthetic":true,"types":[]},{"text":"impl !Send for ExprMatch","synthetic":true,"types":[]},{"text":"impl !Send for ExprMethodCall","synthetic":true,"types":[]},{"text":"impl !Send for ExprParen","synthetic":true,"types":[]},{"text":"impl !Send for ExprPath","synthetic":true,"types":[]},{"text":"impl !Send for ExprRange","synthetic":true,"types":[]},{"text":"impl !Send for ExprReference","synthetic":true,"types":[]},{"text":"impl !Send for ExprRepeat","synthetic":true,"types":[]},{"text":"impl !Send for ExprReturn","synthetic":true,"types":[]},{"text":"impl !Send for ExprStruct","synthetic":true,"types":[]},{"text":"impl !Send for ExprTry","synthetic":true,"types":[]},{"text":"impl !Send for ExprTryBlock","synthetic":true,"types":[]},{"text":"impl !Send for ExprTuple","synthetic":true,"types":[]},{"text":"impl !Send for ExprType","synthetic":true,"types":[]},{"text":"impl !Send for ExprUnary","synthetic":true,"types":[]},{"text":"impl !Send for ExprUnsafe","synthetic":true,"types":[]},{"text":"impl !Send for ExprWhile","synthetic":true,"types":[]},{"text":"impl !Send for ExprYield","synthetic":true,"types":[]},{"text":"impl !Send for Member","synthetic":true,"types":[]},{"text":"impl !Send for Index","synthetic":true,"types":[]},{"text":"impl !Send for Generics","synthetic":true,"types":[]},{"text":"impl !Send for GenericParam","synthetic":true,"types":[]},{"text":"impl !Send for TypeParam","synthetic":true,"types":[]},{"text":"impl !Send for LifetimeDef","synthetic":true,"types":[]},{"text":"impl !Send for ConstParam","synthetic":true,"types":[]},{"text":"impl<'a> !Send for ImplGenerics<'a>","synthetic":true,"types":[]},{"text":"impl<'a> !Send for TypeGenerics<'a>","synthetic":true,"types":[]},{"text":"impl<'a> !Send for Turbofish<'a>","synthetic":true,"types":[]},{"text":"impl !Send for BoundLifetimes","synthetic":true,"types":[]},{"text":"impl !Send for TypeParamBound","synthetic":true,"types":[]},{"text":"impl !Send for TraitBound","synthetic":true,"types":[]},{"text":"impl !Send for TraitBoundModifier","synthetic":true,"types":[]},{"text":"impl !Send for WhereClause","synthetic":true,"types":[]},{"text":"impl !Send for WherePredicate","synthetic":true,"types":[]},{"text":"impl !Send for PredicateType","synthetic":true,"types":[]},{"text":"impl !Send for PredicateLifetime","synthetic":true,"types":[]},{"text":"impl !Send for PredicateEq","synthetic":true,"types":[]},{"text":"impl !Send for Lifetime","synthetic":true,"types":[]},{"text":"impl !Send for Lit","synthetic":true,"types":[]},{"text":"impl !Send for LitStr","synthetic":true,"types":[]},{"text":"impl !Send for LitByteStr","synthetic":true,"types":[]},{"text":"impl !Send for LitByte","synthetic":true,"types":[]},{"text":"impl !Send for LitChar","synthetic":true,"types":[]},{"text":"impl !Send for LitInt","synthetic":true,"types":[]},{"text":"impl !Send for LitFloat","synthetic":true,"types":[]},{"text":"impl !Send for LitBool","synthetic":true,"types":[]},{"text":"impl Send for StrStyle","synthetic":true,"types":[]},{"text":"impl !Send for Macro","synthetic":true,"types":[]},{"text":"impl !Send for MacroDelimiter","synthetic":true,"types":[]},{"text":"impl !Send for DeriveInput","synthetic":true,"types":[]},{"text":"impl !Send for Data","synthetic":true,"types":[]},{"text":"impl !Send for DataStruct","synthetic":true,"types":[]},{"text":"impl !Send for DataEnum","synthetic":true,"types":[]},{"text":"impl !Send for DataUnion","synthetic":true,"types":[]},{"text":"impl !Send for BinOp","synthetic":true,"types":[]},{"text":"impl !Send for UnOp","synthetic":true,"types":[]},{"text":"impl !Send for Type","synthetic":true,"types":[]},{"text":"impl !Send for TypeArray","synthetic":true,"types":[]},{"text":"impl !Send for TypeBareFn","synthetic":true,"types":[]},{"text":"impl !Send for TypeGroup","synthetic":true,"types":[]},{"text":"impl !Send for TypeImplTrait","synthetic":true,"types":[]},{"text":"impl !Send for TypeInfer","synthetic":true,"types":[]},{"text":"impl !Send for TypeMacro","synthetic":true,"types":[]},{"text":"impl !Send for TypeNever","synthetic":true,"types":[]},{"text":"impl !Send for TypeParen","synthetic":true,"types":[]},{"text":"impl !Send for TypePath","synthetic":true,"types":[]},{"text":"impl !Send for TypePtr","synthetic":true,"types":[]},{"text":"impl !Send for TypeReference","synthetic":true,"types":[]},{"text":"impl !Send for TypeSlice","synthetic":true,"types":[]},{"text":"impl !Send for TypeTraitObject","synthetic":true,"types":[]},{"text":"impl !Send for TypeTuple","synthetic":true,"types":[]},{"text":"impl !Send for Abi","synthetic":true,"types":[]},{"text":"impl !Send for BareFnArg","synthetic":true,"types":[]},{"text":"impl !Send for Variadic","synthetic":true,"types":[]},{"text":"impl !Send for ReturnType","synthetic":true,"types":[]},{"text":"impl !Send for Path","synthetic":true,"types":[]},{"text":"impl !Send for PathSegment","synthetic":true,"types":[]},{"text":"impl !Send for PathArguments","synthetic":true,"types":[]},{"text":"impl !Send for GenericArgument","synthetic":true,"types":[]},{"text":"impl !Send for AngleBracketedGenericArguments","synthetic":true,"types":[]},{"text":"impl !Send for Binding","synthetic":true,"types":[]},{"text":"impl !Send for Constraint","synthetic":true,"types":[]},{"text":"impl !Send for ParenthesizedGenericArguments","synthetic":true,"types":[]},{"text":"impl !Send for QSelf","synthetic":true,"types":[]},{"text":"impl !Send for TokenBuffer","synthetic":true,"types":[]},{"text":"impl<'a> !Send for Cursor<'a>","synthetic":true,"types":[]},{"text":"impl<T, P> Send for Punctuated<T, P> where
    P: Send,
    T: Send, ","synthetic":true,"types":[]},{"text":"impl<'a, T, P> Send for Pairs<'a, T, P> where
    P: Sync,
    T: Sync, ","synthetic":true,"types":[]},{"text":"impl<'a, T, P> Send for PairsMut<'a, T, P> where
    P: Send,
    T: Send, ","synthetic":true,"types":[]},{"text":"impl<T, P> Send for IntoPairs<T, P> where
    P: Send,
    T: Send, ","synthetic":true,"types":[]},{"text":"impl<T> Send for IntoIter<T> where
    T: Send, ","synthetic":true,"types":[]},{"text":"impl<'a, T> !Send for Iter<'a, T>","synthetic":true,"types":[]},{"text":"impl<'a, T> !Send for IterMut<'a, T>","synthetic":true,"types":[]},{"text":"impl<T, P> Send for Pair<T, P> where
    P: Send,
    T: Send, ","synthetic":true,"types":[]},{"text":"impl<'a> !Send for Lookahead1<'a>","synthetic":true,"types":[]},{"text":"impl Send for Error","synthetic":true,"types":[]},{"text":"impl<'a> !Send for ParseBuffer<'a>","synthetic":true,"types":[]},{"text":"impl<'c, 'a> !Send for StepCursor<'c, 'a>","synthetic":true,"types":[]},{"text":"impl Send for Nothing","synthetic":true,"types":[]}]; -implementors["synstructure"] = [{"text":"impl Send for AddBounds","synthetic":true,"types":[]},{"text":"impl Send for BindStyle","synthetic":true,"types":[]},{"text":"impl<'a> !Send for BindingInfo<'a>","synthetic":true,"types":[]},{"text":"impl<'a> !Send for VariantAst<'a>","synthetic":true,"types":[]},{"text":"impl<'a> !Send for VariantInfo<'a>","synthetic":true,"types":[]},{"text":"impl<'a> !Send for Structure<'a>","synthetic":true,"types":[]}]; +implementors["delog"] = [{"text":"impl Send for U1","synthetic":true,"types":["delog::hex::U1"]},{"text":"impl<'a, T: ?Sized, U, S> Send for HexStr<'a, T, U, S> where
    S: Send,
    T: Sync,
    U: Send, ","synthetic":true,"types":["delog::hex::HexStr"]},{"text":"impl Send for Statistics","synthetic":true,"types":["delog::logger::Statistics"]},{"text":"impl Send for RipgrepRenderer","synthetic":true,"types":["delog::render::RipgrepRenderer"]},{"text":"impl Send for DefaultRenderer","synthetic":false,"types":["delog::render::DefaultRenderer"]}]; +implementors["flexiber"] = [{"text":"impl<'a> Send for Decoder<'a>","synthetic":true,"types":["flexiber::decoder::Decoder"]},{"text":"impl<'a> Send for Encoder<'a>","synthetic":true,"types":["flexiber::encoder::Encoder"]},{"text":"impl Send for Error","synthetic":true,"types":["flexiber::error::Error"]},{"text":"impl Send for ErrorKind","synthetic":true,"types":["flexiber::error::ErrorKind"]},{"text":"impl Send for Length","synthetic":true,"types":["flexiber::length::Length"]},{"text":"impl Send for SimpleTag","synthetic":true,"types":["flexiber::simpletag::SimpleTag"]},{"text":"impl<'a> Send for Slice<'a>","synthetic":true,"types":["flexiber::slice::Slice"]},{"text":"impl Send for Class","synthetic":true,"types":["flexiber::tag::Class"]},{"text":"impl Send for Tag","synthetic":true,"types":["flexiber::tag::Tag"]},{"text":"impl<V, T> Send for TaggedValue<V, T> where
    T: Send,
    V: Send, ","synthetic":true,"types":["flexiber::tagged::TaggedValue"]}]; +implementors["log"] = [{"text":"impl Send for Level","synthetic":true,"types":["log::Level"]},{"text":"impl Send for LevelFilter","synthetic":true,"types":["log::LevelFilter"]},{"text":"impl<'a> !Send for Record<'a>","synthetic":true,"types":["log::Record"]},{"text":"impl<'a> !Send for RecordBuilder<'a>","synthetic":true,"types":["log::RecordBuilder"]},{"text":"impl<'a> Send for Metadata<'a>","synthetic":true,"types":["log::Metadata"]},{"text":"impl<'a> Send for MetadataBuilder<'a>","synthetic":true,"types":["log::MetadataBuilder"]},{"text":"impl Send for SetLoggerError","synthetic":true,"types":["log::SetLoggerError"]},{"text":"impl Send for ParseLevelError","synthetic":true,"types":["log::ParseLevelError"]}]; +implementors["proc_macro2"] = [{"text":"impl !Send for IntoIter","synthetic":true,"types":["proc_macro2::token_stream::IntoIter"]},{"text":"impl !Send for TokenStream","synthetic":true,"types":["proc_macro2::TokenStream"]},{"text":"impl !Send for LexError","synthetic":true,"types":["proc_macro2::LexError"]},{"text":"impl !Send for Span","synthetic":true,"types":["proc_macro2::Span"]},{"text":"impl !Send for TokenTree","synthetic":true,"types":["proc_macro2::TokenTree"]},{"text":"impl !Send for Group","synthetic":true,"types":["proc_macro2::Group"]},{"text":"impl Send for Delimiter","synthetic":true,"types":["proc_macro2::Delimiter"]},{"text":"impl !Send for Punct","synthetic":true,"types":["proc_macro2::Punct"]},{"text":"impl Send for Spacing","synthetic":true,"types":["proc_macro2::Spacing"]},{"text":"impl !Send for Ident","synthetic":true,"types":["proc_macro2::Ident"]},{"text":"impl !Send for Literal","synthetic":true,"types":["proc_macro2::Literal"]}]; +implementors["syn"] = [{"text":"impl !Send for Underscore","synthetic":true,"types":["syn::token::Underscore"]},{"text":"impl !Send for Abstract","synthetic":true,"types":["syn::token::Abstract"]},{"text":"impl !Send for As","synthetic":true,"types":["syn::token::As"]},{"text":"impl !Send for Async","synthetic":true,"types":["syn::token::Async"]},{"text":"impl !Send for Auto","synthetic":true,"types":["syn::token::Auto"]},{"text":"impl !Send for Await","synthetic":true,"types":["syn::token::Await"]},{"text":"impl !Send for Become","synthetic":true,"types":["syn::token::Become"]},{"text":"impl !Send for Box","synthetic":true,"types":["syn::token::Box"]},{"text":"impl !Send for Break","synthetic":true,"types":["syn::token::Break"]},{"text":"impl !Send for Const","synthetic":true,"types":["syn::token::Const"]},{"text":"impl !Send for Continue","synthetic":true,"types":["syn::token::Continue"]},{"text":"impl !Send for Crate","synthetic":true,"types":["syn::token::Crate"]},{"text":"impl !Send for Default","synthetic":true,"types":["syn::token::Default"]},{"text":"impl !Send for Do","synthetic":true,"types":["syn::token::Do"]},{"text":"impl !Send for Dyn","synthetic":true,"types":["syn::token::Dyn"]},{"text":"impl !Send for Else","synthetic":true,"types":["syn::token::Else"]},{"text":"impl !Send for Enum","synthetic":true,"types":["syn::token::Enum"]},{"text":"impl !Send for Extern","synthetic":true,"types":["syn::token::Extern"]},{"text":"impl !Send for Final","synthetic":true,"types":["syn::token::Final"]},{"text":"impl !Send for Fn","synthetic":true,"types":["syn::token::Fn"]},{"text":"impl !Send for For","synthetic":true,"types":["syn::token::For"]},{"text":"impl !Send for If","synthetic":true,"types":["syn::token::If"]},{"text":"impl !Send for Impl","synthetic":true,"types":["syn::token::Impl"]},{"text":"impl !Send for In","synthetic":true,"types":["syn::token::In"]},{"text":"impl !Send for Let","synthetic":true,"types":["syn::token::Let"]},{"text":"impl !Send for Loop","synthetic":true,"types":["syn::token::Loop"]},{"text":"impl !Send for Macro","synthetic":true,"types":["syn::token::Macro"]},{"text":"impl !Send for Match","synthetic":true,"types":["syn::token::Match"]},{"text":"impl !Send for Mod","synthetic":true,"types":["syn::token::Mod"]},{"text":"impl !Send for Move","synthetic":true,"types":["syn::token::Move"]},{"text":"impl !Send for Mut","synthetic":true,"types":["syn::token::Mut"]},{"text":"impl !Send for Override","synthetic":true,"types":["syn::token::Override"]},{"text":"impl !Send for Priv","synthetic":true,"types":["syn::token::Priv"]},{"text":"impl !Send for Pub","synthetic":true,"types":["syn::token::Pub"]},{"text":"impl !Send for Ref","synthetic":true,"types":["syn::token::Ref"]},{"text":"impl !Send for Return","synthetic":true,"types":["syn::token::Return"]},{"text":"impl !Send for SelfType","synthetic":true,"types":["syn::token::SelfType"]},{"text":"impl !Send for SelfValue","synthetic":true,"types":["syn::token::SelfValue"]},{"text":"impl !Send for Static","synthetic":true,"types":["syn::token::Static"]},{"text":"impl !Send for Struct","synthetic":true,"types":["syn::token::Struct"]},{"text":"impl !Send for Super","synthetic":true,"types":["syn::token::Super"]},{"text":"impl !Send for Trait","synthetic":true,"types":["syn::token::Trait"]},{"text":"impl !Send for Try","synthetic":true,"types":["syn::token::Try"]},{"text":"impl !Send for Type","synthetic":true,"types":["syn::token::Type"]},{"text":"impl !Send for Typeof","synthetic":true,"types":["syn::token::Typeof"]},{"text":"impl !Send for Union","synthetic":true,"types":["syn::token::Union"]},{"text":"impl !Send for Unsafe","synthetic":true,"types":["syn::token::Unsafe"]},{"text":"impl !Send for Unsized","synthetic":true,"types":["syn::token::Unsized"]},{"text":"impl !Send for Use","synthetic":true,"types":["syn::token::Use"]},{"text":"impl !Send for Virtual","synthetic":true,"types":["syn::token::Virtual"]},{"text":"impl !Send for Where","synthetic":true,"types":["syn::token::Where"]},{"text":"impl !Send for While","synthetic":true,"types":["syn::token::While"]},{"text":"impl !Send for Yield","synthetic":true,"types":["syn::token::Yield"]},{"text":"impl !Send for Add","synthetic":true,"types":["syn::token::Add"]},{"text":"impl !Send for AddEq","synthetic":true,"types":["syn::token::AddEq"]},{"text":"impl !Send for And","synthetic":true,"types":["syn::token::And"]},{"text":"impl !Send for AndAnd","synthetic":true,"types":["syn::token::AndAnd"]},{"text":"impl !Send for AndEq","synthetic":true,"types":["syn::token::AndEq"]},{"text":"impl !Send for At","synthetic":true,"types":["syn::token::At"]},{"text":"impl !Send for Bang","synthetic":true,"types":["syn::token::Bang"]},{"text":"impl !Send for Caret","synthetic":true,"types":["syn::token::Caret"]},{"text":"impl !Send for CaretEq","synthetic":true,"types":["syn::token::CaretEq"]},{"text":"impl !Send for Colon","synthetic":true,"types":["syn::token::Colon"]},{"text":"impl !Send for Colon2","synthetic":true,"types":["syn::token::Colon2"]},{"text":"impl !Send for Comma","synthetic":true,"types":["syn::token::Comma"]},{"text":"impl !Send for Div","synthetic":true,"types":["syn::token::Div"]},{"text":"impl !Send for DivEq","synthetic":true,"types":["syn::token::DivEq"]},{"text":"impl !Send for Dollar","synthetic":true,"types":["syn::token::Dollar"]},{"text":"impl !Send for Dot","synthetic":true,"types":["syn::token::Dot"]},{"text":"impl !Send for Dot2","synthetic":true,"types":["syn::token::Dot2"]},{"text":"impl !Send for Dot3","synthetic":true,"types":["syn::token::Dot3"]},{"text":"impl !Send for DotDotEq","synthetic":true,"types":["syn::token::DotDotEq"]},{"text":"impl !Send for Eq","synthetic":true,"types":["syn::token::Eq"]},{"text":"impl !Send for EqEq","synthetic":true,"types":["syn::token::EqEq"]},{"text":"impl !Send for Ge","synthetic":true,"types":["syn::token::Ge"]},{"text":"impl !Send for Gt","synthetic":true,"types":["syn::token::Gt"]},{"text":"impl !Send for Le","synthetic":true,"types":["syn::token::Le"]},{"text":"impl !Send for Lt","synthetic":true,"types":["syn::token::Lt"]},{"text":"impl !Send for MulEq","synthetic":true,"types":["syn::token::MulEq"]},{"text":"impl !Send for Ne","synthetic":true,"types":["syn::token::Ne"]},{"text":"impl !Send for Or","synthetic":true,"types":["syn::token::Or"]},{"text":"impl !Send for OrEq","synthetic":true,"types":["syn::token::OrEq"]},{"text":"impl !Send for OrOr","synthetic":true,"types":["syn::token::OrOr"]},{"text":"impl !Send for Pound","synthetic":true,"types":["syn::token::Pound"]},{"text":"impl !Send for Question","synthetic":true,"types":["syn::token::Question"]},{"text":"impl !Send for RArrow","synthetic":true,"types":["syn::token::RArrow"]},{"text":"impl !Send for LArrow","synthetic":true,"types":["syn::token::LArrow"]},{"text":"impl !Send for Rem","synthetic":true,"types":["syn::token::Rem"]},{"text":"impl !Send for RemEq","synthetic":true,"types":["syn::token::RemEq"]},{"text":"impl !Send for FatArrow","synthetic":true,"types":["syn::token::FatArrow"]},{"text":"impl !Send for Semi","synthetic":true,"types":["syn::token::Semi"]},{"text":"impl !Send for Shl","synthetic":true,"types":["syn::token::Shl"]},{"text":"impl !Send for ShlEq","synthetic":true,"types":["syn::token::ShlEq"]},{"text":"impl !Send for Shr","synthetic":true,"types":["syn::token::Shr"]},{"text":"impl !Send for ShrEq","synthetic":true,"types":["syn::token::ShrEq"]},{"text":"impl !Send for Star","synthetic":true,"types":["syn::token::Star"]},{"text":"impl !Send for Sub","synthetic":true,"types":["syn::token::Sub"]},{"text":"impl !Send for SubEq","synthetic":true,"types":["syn::token::SubEq"]},{"text":"impl !Send for Tilde","synthetic":true,"types":["syn::token::Tilde"]},{"text":"impl !Send for Brace","synthetic":true,"types":["syn::token::Brace"]},{"text":"impl !Send for Bracket","synthetic":true,"types":["syn::token::Bracket"]},{"text":"impl !Send for Paren","synthetic":true,"types":["syn::token::Paren"]},{"text":"impl !Send for Group","synthetic":true,"types":["syn::token::Group"]},{"text":"impl !Send for Attribute","synthetic":true,"types":["syn::attr::Attribute"]},{"text":"impl !Send for AttrStyle","synthetic":true,"types":["syn::attr::AttrStyle"]},{"text":"impl !Send for Meta","synthetic":true,"types":["syn::attr::Meta"]},{"text":"impl !Send for MetaList","synthetic":true,"types":["syn::attr::MetaList"]},{"text":"impl !Send for MetaNameValue","synthetic":true,"types":["syn::attr::MetaNameValue"]},{"text":"impl !Send for NestedMeta","synthetic":true,"types":["syn::attr::NestedMeta"]},{"text":"impl !Send for Variant","synthetic":true,"types":["syn::data::Variant"]},{"text":"impl !Send for Fields","synthetic":true,"types":["syn::data::Fields"]},{"text":"impl !Send for FieldsNamed","synthetic":true,"types":["syn::data::FieldsNamed"]},{"text":"impl !Send for FieldsUnnamed","synthetic":true,"types":["syn::data::FieldsUnnamed"]},{"text":"impl !Send for Field","synthetic":true,"types":["syn::data::Field"]},{"text":"impl !Send for Visibility","synthetic":true,"types":["syn::data::Visibility"]},{"text":"impl !Send for VisPublic","synthetic":true,"types":["syn::data::VisPublic"]},{"text":"impl !Send for VisCrate","synthetic":true,"types":["syn::data::VisCrate"]},{"text":"impl !Send for VisRestricted","synthetic":true,"types":["syn::data::VisRestricted"]},{"text":"impl !Send for Expr","synthetic":true,"types":["syn::expr::Expr"]},{"text":"impl !Send for ExprArray","synthetic":true,"types":["syn::expr::ExprArray"]},{"text":"impl !Send for ExprAssign","synthetic":true,"types":["syn::expr::ExprAssign"]},{"text":"impl !Send for ExprAssignOp","synthetic":true,"types":["syn::expr::ExprAssignOp"]},{"text":"impl !Send for ExprAsync","synthetic":true,"types":["syn::expr::ExprAsync"]},{"text":"impl !Send for ExprAwait","synthetic":true,"types":["syn::expr::ExprAwait"]},{"text":"impl !Send for ExprBinary","synthetic":true,"types":["syn::expr::ExprBinary"]},{"text":"impl !Send for ExprBlock","synthetic":true,"types":["syn::expr::ExprBlock"]},{"text":"impl !Send for ExprBox","synthetic":true,"types":["syn::expr::ExprBox"]},{"text":"impl !Send for ExprBreak","synthetic":true,"types":["syn::expr::ExprBreak"]},{"text":"impl !Send for ExprCall","synthetic":true,"types":["syn::expr::ExprCall"]},{"text":"impl !Send for ExprCast","synthetic":true,"types":["syn::expr::ExprCast"]},{"text":"impl !Send for ExprClosure","synthetic":true,"types":["syn::expr::ExprClosure"]},{"text":"impl !Send for ExprContinue","synthetic":true,"types":["syn::expr::ExprContinue"]},{"text":"impl !Send for ExprField","synthetic":true,"types":["syn::expr::ExprField"]},{"text":"impl !Send for ExprForLoop","synthetic":true,"types":["syn::expr::ExprForLoop"]},{"text":"impl !Send for ExprGroup","synthetic":true,"types":["syn::expr::ExprGroup"]},{"text":"impl !Send for ExprIf","synthetic":true,"types":["syn::expr::ExprIf"]},{"text":"impl !Send for ExprIndex","synthetic":true,"types":["syn::expr::ExprIndex"]},{"text":"impl !Send for ExprLet","synthetic":true,"types":["syn::expr::ExprLet"]},{"text":"impl !Send for ExprLit","synthetic":true,"types":["syn::expr::ExprLit"]},{"text":"impl !Send for ExprLoop","synthetic":true,"types":["syn::expr::ExprLoop"]},{"text":"impl !Send for ExprMacro","synthetic":true,"types":["syn::expr::ExprMacro"]},{"text":"impl !Send for ExprMatch","synthetic":true,"types":["syn::expr::ExprMatch"]},{"text":"impl !Send for ExprMethodCall","synthetic":true,"types":["syn::expr::ExprMethodCall"]},{"text":"impl !Send for ExprParen","synthetic":true,"types":["syn::expr::ExprParen"]},{"text":"impl !Send for ExprPath","synthetic":true,"types":["syn::expr::ExprPath"]},{"text":"impl !Send for ExprRange","synthetic":true,"types":["syn::expr::ExprRange"]},{"text":"impl !Send for ExprReference","synthetic":true,"types":["syn::expr::ExprReference"]},{"text":"impl !Send for ExprRepeat","synthetic":true,"types":["syn::expr::ExprRepeat"]},{"text":"impl !Send for ExprReturn","synthetic":true,"types":["syn::expr::ExprReturn"]},{"text":"impl !Send for ExprStruct","synthetic":true,"types":["syn::expr::ExprStruct"]},{"text":"impl !Send for ExprTry","synthetic":true,"types":["syn::expr::ExprTry"]},{"text":"impl !Send for ExprTryBlock","synthetic":true,"types":["syn::expr::ExprTryBlock"]},{"text":"impl !Send for ExprTuple","synthetic":true,"types":["syn::expr::ExprTuple"]},{"text":"impl !Send for ExprType","synthetic":true,"types":["syn::expr::ExprType"]},{"text":"impl !Send for ExprUnary","synthetic":true,"types":["syn::expr::ExprUnary"]},{"text":"impl !Send for ExprUnsafe","synthetic":true,"types":["syn::expr::ExprUnsafe"]},{"text":"impl !Send for ExprWhile","synthetic":true,"types":["syn::expr::ExprWhile"]},{"text":"impl !Send for ExprYield","synthetic":true,"types":["syn::expr::ExprYield"]},{"text":"impl !Send for Member","synthetic":true,"types":["syn::expr::Member"]},{"text":"impl !Send for Index","synthetic":true,"types":["syn::expr::Index"]},{"text":"impl !Send for Generics","synthetic":true,"types":["syn::generics::Generics"]},{"text":"impl !Send for GenericParam","synthetic":true,"types":["syn::generics::GenericParam"]},{"text":"impl !Send for TypeParam","synthetic":true,"types":["syn::generics::TypeParam"]},{"text":"impl !Send for LifetimeDef","synthetic":true,"types":["syn::generics::LifetimeDef"]},{"text":"impl !Send for ConstParam","synthetic":true,"types":["syn::generics::ConstParam"]},{"text":"impl<'a> !Send for ImplGenerics<'a>","synthetic":true,"types":["syn::generics::ImplGenerics"]},{"text":"impl<'a> !Send for TypeGenerics<'a>","synthetic":true,"types":["syn::generics::TypeGenerics"]},{"text":"impl<'a> !Send for Turbofish<'a>","synthetic":true,"types":["syn::generics::Turbofish"]},{"text":"impl !Send for BoundLifetimes","synthetic":true,"types":["syn::generics::BoundLifetimes"]},{"text":"impl !Send for TypeParamBound","synthetic":true,"types":["syn::generics::TypeParamBound"]},{"text":"impl !Send for TraitBound","synthetic":true,"types":["syn::generics::TraitBound"]},{"text":"impl !Send for TraitBoundModifier","synthetic":true,"types":["syn::generics::TraitBoundModifier"]},{"text":"impl !Send for WhereClause","synthetic":true,"types":["syn::generics::WhereClause"]},{"text":"impl !Send for WherePredicate","synthetic":true,"types":["syn::generics::WherePredicate"]},{"text":"impl !Send for PredicateType","synthetic":true,"types":["syn::generics::PredicateType"]},{"text":"impl !Send for PredicateLifetime","synthetic":true,"types":["syn::generics::PredicateLifetime"]},{"text":"impl !Send for PredicateEq","synthetic":true,"types":["syn::generics::PredicateEq"]},{"text":"impl !Send for Lifetime","synthetic":true,"types":["syn::lifetime::Lifetime"]},{"text":"impl !Send for Lit","synthetic":true,"types":["syn::lit::Lit"]},{"text":"impl !Send for LitStr","synthetic":true,"types":["syn::lit::LitStr"]},{"text":"impl !Send for LitByteStr","synthetic":true,"types":["syn::lit::LitByteStr"]},{"text":"impl !Send for LitByte","synthetic":true,"types":["syn::lit::LitByte"]},{"text":"impl !Send for LitChar","synthetic":true,"types":["syn::lit::LitChar"]},{"text":"impl !Send for LitInt","synthetic":true,"types":["syn::lit::LitInt"]},{"text":"impl !Send for LitFloat","synthetic":true,"types":["syn::lit::LitFloat"]},{"text":"impl !Send for LitBool","synthetic":true,"types":["syn::lit::LitBool"]},{"text":"impl Send for StrStyle","synthetic":true,"types":["syn::lit::StrStyle"]},{"text":"impl !Send for Macro","synthetic":true,"types":["syn::mac::Macro"]},{"text":"impl !Send for MacroDelimiter","synthetic":true,"types":["syn::mac::MacroDelimiter"]},{"text":"impl !Send for DeriveInput","synthetic":true,"types":["syn::derive::DeriveInput"]},{"text":"impl !Send for Data","synthetic":true,"types":["syn::derive::Data"]},{"text":"impl !Send for DataStruct","synthetic":true,"types":["syn::derive::DataStruct"]},{"text":"impl !Send for DataEnum","synthetic":true,"types":["syn::derive::DataEnum"]},{"text":"impl !Send for DataUnion","synthetic":true,"types":["syn::derive::DataUnion"]},{"text":"impl !Send for BinOp","synthetic":true,"types":["syn::op::BinOp"]},{"text":"impl !Send for UnOp","synthetic":true,"types":["syn::op::UnOp"]},{"text":"impl !Send for Type","synthetic":true,"types":["syn::ty::Type"]},{"text":"impl !Send for TypeArray","synthetic":true,"types":["syn::ty::TypeArray"]},{"text":"impl !Send for TypeBareFn","synthetic":true,"types":["syn::ty::TypeBareFn"]},{"text":"impl !Send for TypeGroup","synthetic":true,"types":["syn::ty::TypeGroup"]},{"text":"impl !Send for TypeImplTrait","synthetic":true,"types":["syn::ty::TypeImplTrait"]},{"text":"impl !Send for TypeInfer","synthetic":true,"types":["syn::ty::TypeInfer"]},{"text":"impl !Send for TypeMacro","synthetic":true,"types":["syn::ty::TypeMacro"]},{"text":"impl !Send for TypeNever","synthetic":true,"types":["syn::ty::TypeNever"]},{"text":"impl !Send for TypeParen","synthetic":true,"types":["syn::ty::TypeParen"]},{"text":"impl !Send for TypePath","synthetic":true,"types":["syn::ty::TypePath"]},{"text":"impl !Send for TypePtr","synthetic":true,"types":["syn::ty::TypePtr"]},{"text":"impl !Send for TypeReference","synthetic":true,"types":["syn::ty::TypeReference"]},{"text":"impl !Send for TypeSlice","synthetic":true,"types":["syn::ty::TypeSlice"]},{"text":"impl !Send for TypeTraitObject","synthetic":true,"types":["syn::ty::TypeTraitObject"]},{"text":"impl !Send for TypeTuple","synthetic":true,"types":["syn::ty::TypeTuple"]},{"text":"impl !Send for Abi","synthetic":true,"types":["syn::ty::Abi"]},{"text":"impl !Send for BareFnArg","synthetic":true,"types":["syn::ty::BareFnArg"]},{"text":"impl !Send for Variadic","synthetic":true,"types":["syn::ty::Variadic"]},{"text":"impl !Send for ReturnType","synthetic":true,"types":["syn::ty::ReturnType"]},{"text":"impl !Send for Path","synthetic":true,"types":["syn::path::Path"]},{"text":"impl !Send for PathSegment","synthetic":true,"types":["syn::path::PathSegment"]},{"text":"impl !Send for PathArguments","synthetic":true,"types":["syn::path::PathArguments"]},{"text":"impl !Send for GenericArgument","synthetic":true,"types":["syn::path::GenericArgument"]},{"text":"impl !Send for AngleBracketedGenericArguments","synthetic":true,"types":["syn::path::AngleBracketedGenericArguments"]},{"text":"impl !Send for Binding","synthetic":true,"types":["syn::path::Binding"]},{"text":"impl !Send for Constraint","synthetic":true,"types":["syn::path::Constraint"]},{"text":"impl !Send for ParenthesizedGenericArguments","synthetic":true,"types":["syn::path::ParenthesizedGenericArguments"]},{"text":"impl !Send for QSelf","synthetic":true,"types":["syn::path::QSelf"]},{"text":"impl !Send for TokenBuffer","synthetic":true,"types":["syn::buffer::TokenBuffer"]},{"text":"impl<'a> !Send for Cursor<'a>","synthetic":true,"types":["syn::buffer::Cursor"]},{"text":"impl<T, P> Send for Punctuated<T, P> where
    P: Send,
    T: Send, ","synthetic":true,"types":["syn::punctuated::Punctuated"]},{"text":"impl<'a, T, P> Send for Pairs<'a, T, P> where
    P: Sync,
    T: Sync, ","synthetic":true,"types":["syn::punctuated::Pairs"]},{"text":"impl<'a, T, P> Send for PairsMut<'a, T, P> where
    P: Send,
    T: Send, ","synthetic":true,"types":["syn::punctuated::PairsMut"]},{"text":"impl<T, P> Send for IntoPairs<T, P> where
    P: Send,
    T: Send, ","synthetic":true,"types":["syn::punctuated::IntoPairs"]},{"text":"impl<T> Send for IntoIter<T> where
    T: Send, ","synthetic":true,"types":["syn::punctuated::IntoIter"]},{"text":"impl<'a, T> !Send for Iter<'a, T>","synthetic":true,"types":["syn::punctuated::Iter"]},{"text":"impl<'a, T> !Send for IterMut<'a, T>","synthetic":true,"types":["syn::punctuated::IterMut"]},{"text":"impl<T, P> Send for Pair<T, P> where
    P: Send,
    T: Send, ","synthetic":true,"types":["syn::punctuated::Pair"]},{"text":"impl<'a> !Send for Lookahead1<'a>","synthetic":true,"types":["syn::lookahead::Lookahead1"]},{"text":"impl Send for Error","synthetic":true,"types":["syn::error::Error"]},{"text":"impl<'a> !Send for ParseBuffer<'a>","synthetic":true,"types":["syn::parse::ParseBuffer"]},{"text":"impl<'c, 'a> !Send for StepCursor<'c, 'a>","synthetic":true,"types":["syn::parse::StepCursor"]},{"text":"impl Send for Nothing","synthetic":true,"types":["syn::parse::Nothing"]}]; +implementors["synstructure"] = [{"text":"impl Send for AddBounds","synthetic":true,"types":["synstructure::AddBounds"]},{"text":"impl Send for BindStyle","synthetic":true,"types":["synstructure::BindStyle"]},{"text":"impl<'a> !Send for BindingInfo<'a>","synthetic":true,"types":["synstructure::BindingInfo"]},{"text":"impl<'a> !Send for VariantAst<'a>","synthetic":true,"types":["synstructure::VariantAst"]},{"text":"impl<'a> !Send for VariantInfo<'a>","synthetic":true,"types":["synstructure::VariantInfo"]},{"text":"impl<'a> !Send for Structure<'a>","synthetic":true,"types":["synstructure::Structure"]}]; if (window.register_implementors) {window.register_implementors(implementors);} else {window.pending_implementors = implementors;}})() \ No newline at end of file diff --git a/implementors/core/marker/trait.StructuralEq.js b/implementors/core/marker/trait.StructuralEq.js index 91a72da..4943ae8 100644 --- a/implementors/core/marker/trait.StructuralEq.js +++ b/implementors/core/marker/trait.StructuralEq.js @@ -1,6 +1,6 @@ (function() {var implementors = {}; -implementors["flexiber"] = [{"text":"impl StructuralEq for Error","synthetic":false,"types":[]},{"text":"impl StructuralEq for ErrorKind","synthetic":false,"types":[]},{"text":"impl StructuralEq for Length","synthetic":false,"types":[]},{"text":"impl StructuralEq for SimpleTag","synthetic":false,"types":[]},{"text":"impl<'a> StructuralEq for Slice<'a>","synthetic":false,"types":[]},{"text":"impl StructuralEq for Class","synthetic":false,"types":[]},{"text":"impl StructuralEq for Tag","synthetic":false,"types":[]},{"text":"impl<V, T> StructuralEq for TaggedValue<V, T>","synthetic":false,"types":[]}]; -implementors["log"] = [{"text":"impl StructuralEq for Level","synthetic":false,"types":[]},{"text":"impl StructuralEq for LevelFilter","synthetic":false,"types":[]},{"text":"impl<'a> StructuralEq for Metadata<'a>","synthetic":false,"types":[]},{"text":"impl<'a> StructuralEq for MetadataBuilder<'a>","synthetic":false,"types":[]}]; -implementors["proc_macro2"] = [{"text":"impl StructuralEq for Delimiter","synthetic":false,"types":[]},{"text":"impl StructuralEq for Spacing","synthetic":false,"types":[]}]; -implementors["synstructure"] = [{"text":"impl StructuralEq for AddBounds","synthetic":false,"types":[]},{"text":"impl StructuralEq for BindStyle","synthetic":false,"types":[]},{"text":"impl<'a> StructuralEq for BindingInfo<'a>","synthetic":false,"types":[]},{"text":"impl<'a> StructuralEq for VariantAst<'a>","synthetic":false,"types":[]},{"text":"impl<'a> StructuralEq for VariantInfo<'a>","synthetic":false,"types":[]},{"text":"impl<'a> StructuralEq for Structure<'a>","synthetic":false,"types":[]}]; +implementors["flexiber"] = [{"text":"impl StructuralEq for Error","synthetic":false,"types":["flexiber::error::Error"]},{"text":"impl StructuralEq for ErrorKind","synthetic":false,"types":["flexiber::error::ErrorKind"]},{"text":"impl StructuralEq for Length","synthetic":false,"types":["flexiber::length::Length"]},{"text":"impl StructuralEq for SimpleTag","synthetic":false,"types":["flexiber::simpletag::SimpleTag"]},{"text":"impl<'a> StructuralEq for Slice<'a>","synthetic":false,"types":["flexiber::slice::Slice"]},{"text":"impl StructuralEq for Class","synthetic":false,"types":["flexiber::tag::Class"]},{"text":"impl StructuralEq for Tag","synthetic":false,"types":["flexiber::tag::Tag"]},{"text":"impl<V, T> StructuralEq for TaggedValue<V, T>","synthetic":false,"types":["flexiber::tagged::TaggedValue"]}]; +implementors["log"] = [{"text":"impl StructuralEq for Level","synthetic":false,"types":["log::Level"]},{"text":"impl StructuralEq for LevelFilter","synthetic":false,"types":["log::LevelFilter"]},{"text":"impl<'a> StructuralEq for Metadata<'a>","synthetic":false,"types":["log::Metadata"]},{"text":"impl<'a> StructuralEq for MetadataBuilder<'a>","synthetic":false,"types":["log::MetadataBuilder"]}]; +implementors["proc_macro2"] = [{"text":"impl StructuralEq for Delimiter","synthetic":false,"types":["proc_macro2::Delimiter"]},{"text":"impl StructuralEq for Spacing","synthetic":false,"types":["proc_macro2::Spacing"]}]; +implementors["synstructure"] = [{"text":"impl StructuralEq for AddBounds","synthetic":false,"types":["synstructure::AddBounds"]},{"text":"impl StructuralEq for BindStyle","synthetic":false,"types":["synstructure::BindStyle"]},{"text":"impl<'a> StructuralEq for BindingInfo<'a>","synthetic":false,"types":["synstructure::BindingInfo"]},{"text":"impl<'a> StructuralEq for VariantAst<'a>","synthetic":false,"types":["synstructure::VariantAst"]},{"text":"impl<'a> StructuralEq for VariantInfo<'a>","synthetic":false,"types":["synstructure::VariantInfo"]},{"text":"impl<'a> StructuralEq for Structure<'a>","synthetic":false,"types":["synstructure::Structure"]}]; if (window.register_implementors) {window.register_implementors(implementors);} else {window.pending_implementors = implementors;}})() \ No newline at end of file diff --git a/implementors/core/marker/trait.StructuralPartialEq.js b/implementors/core/marker/trait.StructuralPartialEq.js index 442bab5..f29d668 100644 --- a/implementors/core/marker/trait.StructuralPartialEq.js +++ b/implementors/core/marker/trait.StructuralPartialEq.js @@ -1,6 +1,6 @@ (function() {var implementors = {}; -implementors["flexiber"] = [{"text":"impl StructuralPartialEq for Error","synthetic":false,"types":[]},{"text":"impl StructuralPartialEq for ErrorKind","synthetic":false,"types":[]},{"text":"impl StructuralPartialEq for Length","synthetic":false,"types":[]},{"text":"impl StructuralPartialEq for SimpleTag","synthetic":false,"types":[]},{"text":"impl<'a> StructuralPartialEq for Slice<'a>","synthetic":false,"types":[]},{"text":"impl StructuralPartialEq for Class","synthetic":false,"types":[]},{"text":"impl StructuralPartialEq for Tag","synthetic":false,"types":[]},{"text":"impl<V, T> StructuralPartialEq for TaggedValue<V, T>","synthetic":false,"types":[]}]; -implementors["log"] = [{"text":"impl<'a> StructuralPartialEq for Metadata<'a>","synthetic":false,"types":[]},{"text":"impl<'a> StructuralPartialEq for MetadataBuilder<'a>","synthetic":false,"types":[]},{"text":"impl StructuralPartialEq for ParseLevelError","synthetic":false,"types":[]}]; -implementors["proc_macro2"] = [{"text":"impl StructuralPartialEq for Delimiter","synthetic":false,"types":[]},{"text":"impl StructuralPartialEq for Spacing","synthetic":false,"types":[]}]; -implementors["synstructure"] = [{"text":"impl StructuralPartialEq for AddBounds","synthetic":false,"types":[]},{"text":"impl StructuralPartialEq for BindStyle","synthetic":false,"types":[]},{"text":"impl<'a> StructuralPartialEq for BindingInfo<'a>","synthetic":false,"types":[]},{"text":"impl<'a> StructuralPartialEq for VariantAst<'a>","synthetic":false,"types":[]},{"text":"impl<'a> StructuralPartialEq for VariantInfo<'a>","synthetic":false,"types":[]},{"text":"impl<'a> StructuralPartialEq for Structure<'a>","synthetic":false,"types":[]}]; +implementors["flexiber"] = [{"text":"impl StructuralPartialEq for Error","synthetic":false,"types":["flexiber::error::Error"]},{"text":"impl StructuralPartialEq for ErrorKind","synthetic":false,"types":["flexiber::error::ErrorKind"]},{"text":"impl StructuralPartialEq for Length","synthetic":false,"types":["flexiber::length::Length"]},{"text":"impl StructuralPartialEq for SimpleTag","synthetic":false,"types":["flexiber::simpletag::SimpleTag"]},{"text":"impl<'a> StructuralPartialEq for Slice<'a>","synthetic":false,"types":["flexiber::slice::Slice"]},{"text":"impl StructuralPartialEq for Class","synthetic":false,"types":["flexiber::tag::Class"]},{"text":"impl StructuralPartialEq for Tag","synthetic":false,"types":["flexiber::tag::Tag"]},{"text":"impl<V, T> StructuralPartialEq for TaggedValue<V, T>","synthetic":false,"types":["flexiber::tagged::TaggedValue"]}]; +implementors["log"] = [{"text":"impl<'a> StructuralPartialEq for Metadata<'a>","synthetic":false,"types":["log::Metadata"]},{"text":"impl<'a> StructuralPartialEq for MetadataBuilder<'a>","synthetic":false,"types":["log::MetadataBuilder"]},{"text":"impl StructuralPartialEq for ParseLevelError","synthetic":false,"types":["log::ParseLevelError"]}]; +implementors["proc_macro2"] = [{"text":"impl StructuralPartialEq for Delimiter","synthetic":false,"types":["proc_macro2::Delimiter"]},{"text":"impl StructuralPartialEq for Spacing","synthetic":false,"types":["proc_macro2::Spacing"]}]; +implementors["synstructure"] = [{"text":"impl StructuralPartialEq for AddBounds","synthetic":false,"types":["synstructure::AddBounds"]},{"text":"impl StructuralPartialEq for BindStyle","synthetic":false,"types":["synstructure::BindStyle"]},{"text":"impl<'a> StructuralPartialEq for BindingInfo<'a>","synthetic":false,"types":["synstructure::BindingInfo"]},{"text":"impl<'a> StructuralPartialEq for VariantAst<'a>","synthetic":false,"types":["synstructure::VariantAst"]},{"text":"impl<'a> StructuralPartialEq for VariantInfo<'a>","synthetic":false,"types":["synstructure::VariantInfo"]},{"text":"impl<'a> StructuralPartialEq for Structure<'a>","synthetic":false,"types":["synstructure::Structure"]}]; if (window.register_implementors) {window.register_implementors(implementors);} else {window.pending_implementors = implementors;}})() \ No newline at end of file diff --git a/implementors/core/marker/trait.Sync.js b/implementors/core/marker/trait.Sync.js index 02e8c4b..847cb1c 100644 --- a/implementors/core/marker/trait.Sync.js +++ b/implementors/core/marker/trait.Sync.js @@ -1,8 +1,8 @@ (function() {var implementors = {}; -implementors["delog"] = [{"text":"impl Sync for U1","synthetic":true,"types":[]},{"text":"impl<'a, T: ?Sized, U, S> Sync for HexStr<'a, T, U, S> where
    S: Sync,
    T: Sync,
    U: Sync, ","synthetic":true,"types":[]},{"text":"impl Sync for Statistics","synthetic":true,"types":[]},{"text":"impl Sync for RipgrepRenderer","synthetic":true,"types":[]},{"text":"impl Sync for DefaultRenderer","synthetic":false,"types":[]}]; -implementors["flexiber"] = [{"text":"impl<'a> Sync for Decoder<'a>","synthetic":true,"types":[]},{"text":"impl<'a> Sync for Encoder<'a>","synthetic":true,"types":[]},{"text":"impl Sync for Error","synthetic":true,"types":[]},{"text":"impl Sync for ErrorKind","synthetic":true,"types":[]},{"text":"impl Sync for Length","synthetic":true,"types":[]},{"text":"impl Sync for SimpleTag","synthetic":true,"types":[]},{"text":"impl<'a> Sync for Slice<'a>","synthetic":true,"types":[]},{"text":"impl Sync for Class","synthetic":true,"types":[]},{"text":"impl Sync for Tag","synthetic":true,"types":[]},{"text":"impl<V, T> Sync for TaggedValue<V, T> where
    T: Sync,
    V: Sync, ","synthetic":true,"types":[]}]; -implementors["log"] = [{"text":"impl Sync for Level","synthetic":true,"types":[]},{"text":"impl Sync for LevelFilter","synthetic":true,"types":[]},{"text":"impl<'a> !Sync for Record<'a>","synthetic":true,"types":[]},{"text":"impl<'a> !Sync for RecordBuilder<'a>","synthetic":true,"types":[]},{"text":"impl<'a> Sync for Metadata<'a>","synthetic":true,"types":[]},{"text":"impl<'a> Sync for MetadataBuilder<'a>","synthetic":true,"types":[]},{"text":"impl Sync for SetLoggerError","synthetic":true,"types":[]},{"text":"impl Sync for ParseLevelError","synthetic":true,"types":[]}]; -implementors["proc_macro2"] = [{"text":"impl !Sync for IntoIter","synthetic":true,"types":[]},{"text":"impl !Sync for TokenStream","synthetic":true,"types":[]},{"text":"impl !Sync for LexError","synthetic":true,"types":[]},{"text":"impl !Sync for Span","synthetic":true,"types":[]},{"text":"impl !Sync for TokenTree","synthetic":true,"types":[]},{"text":"impl !Sync for Group","synthetic":true,"types":[]},{"text":"impl Sync for Delimiter","synthetic":true,"types":[]},{"text":"impl !Sync for Punct","synthetic":true,"types":[]},{"text":"impl Sync for Spacing","synthetic":true,"types":[]},{"text":"impl !Sync for Ident","synthetic":true,"types":[]},{"text":"impl !Sync for Literal","synthetic":true,"types":[]}]; -implementors["syn"] = [{"text":"impl !Sync for Underscore","synthetic":true,"types":[]},{"text":"impl !Sync for Abstract","synthetic":true,"types":[]},{"text":"impl !Sync for As","synthetic":true,"types":[]},{"text":"impl !Sync for Async","synthetic":true,"types":[]},{"text":"impl !Sync for Auto","synthetic":true,"types":[]},{"text":"impl !Sync for Await","synthetic":true,"types":[]},{"text":"impl !Sync for Become","synthetic":true,"types":[]},{"text":"impl !Sync for Box","synthetic":true,"types":[]},{"text":"impl !Sync for Break","synthetic":true,"types":[]},{"text":"impl !Sync for Const","synthetic":true,"types":[]},{"text":"impl !Sync for Continue","synthetic":true,"types":[]},{"text":"impl !Sync for Crate","synthetic":true,"types":[]},{"text":"impl !Sync for Default","synthetic":true,"types":[]},{"text":"impl !Sync for Do","synthetic":true,"types":[]},{"text":"impl !Sync for Dyn","synthetic":true,"types":[]},{"text":"impl !Sync for Else","synthetic":true,"types":[]},{"text":"impl !Sync for Enum","synthetic":true,"types":[]},{"text":"impl !Sync for Extern","synthetic":true,"types":[]},{"text":"impl !Sync for Final","synthetic":true,"types":[]},{"text":"impl !Sync for Fn","synthetic":true,"types":[]},{"text":"impl !Sync for For","synthetic":true,"types":[]},{"text":"impl !Sync for If","synthetic":true,"types":[]},{"text":"impl !Sync for Impl","synthetic":true,"types":[]},{"text":"impl !Sync for In","synthetic":true,"types":[]},{"text":"impl !Sync for Let","synthetic":true,"types":[]},{"text":"impl !Sync for Loop","synthetic":true,"types":[]},{"text":"impl !Sync for Macro","synthetic":true,"types":[]},{"text":"impl !Sync for Match","synthetic":true,"types":[]},{"text":"impl !Sync for Mod","synthetic":true,"types":[]},{"text":"impl !Sync for Move","synthetic":true,"types":[]},{"text":"impl !Sync for Mut","synthetic":true,"types":[]},{"text":"impl !Sync for Override","synthetic":true,"types":[]},{"text":"impl !Sync for Priv","synthetic":true,"types":[]},{"text":"impl !Sync for Pub","synthetic":true,"types":[]},{"text":"impl !Sync for Ref","synthetic":true,"types":[]},{"text":"impl !Sync for Return","synthetic":true,"types":[]},{"text":"impl !Sync for SelfType","synthetic":true,"types":[]},{"text":"impl !Sync for SelfValue","synthetic":true,"types":[]},{"text":"impl !Sync for Static","synthetic":true,"types":[]},{"text":"impl !Sync for Struct","synthetic":true,"types":[]},{"text":"impl !Sync for Super","synthetic":true,"types":[]},{"text":"impl !Sync for Trait","synthetic":true,"types":[]},{"text":"impl !Sync for Try","synthetic":true,"types":[]},{"text":"impl !Sync for Type","synthetic":true,"types":[]},{"text":"impl !Sync for Typeof","synthetic":true,"types":[]},{"text":"impl !Sync for Union","synthetic":true,"types":[]},{"text":"impl !Sync for Unsafe","synthetic":true,"types":[]},{"text":"impl !Sync for Unsized","synthetic":true,"types":[]},{"text":"impl !Sync for Use","synthetic":true,"types":[]},{"text":"impl !Sync for Virtual","synthetic":true,"types":[]},{"text":"impl !Sync for Where","synthetic":true,"types":[]},{"text":"impl !Sync for While","synthetic":true,"types":[]},{"text":"impl !Sync for Yield","synthetic":true,"types":[]},{"text":"impl !Sync for Add","synthetic":true,"types":[]},{"text":"impl !Sync for AddEq","synthetic":true,"types":[]},{"text":"impl !Sync for And","synthetic":true,"types":[]},{"text":"impl !Sync for AndAnd","synthetic":true,"types":[]},{"text":"impl !Sync for AndEq","synthetic":true,"types":[]},{"text":"impl !Sync for At","synthetic":true,"types":[]},{"text":"impl !Sync for Bang","synthetic":true,"types":[]},{"text":"impl !Sync for Caret","synthetic":true,"types":[]},{"text":"impl !Sync for CaretEq","synthetic":true,"types":[]},{"text":"impl !Sync for Colon","synthetic":true,"types":[]},{"text":"impl !Sync for Colon2","synthetic":true,"types":[]},{"text":"impl !Sync for Comma","synthetic":true,"types":[]},{"text":"impl !Sync for Div","synthetic":true,"types":[]},{"text":"impl !Sync for DivEq","synthetic":true,"types":[]},{"text":"impl !Sync for Dollar","synthetic":true,"types":[]},{"text":"impl !Sync for Dot","synthetic":true,"types":[]},{"text":"impl !Sync for Dot2","synthetic":true,"types":[]},{"text":"impl !Sync for Dot3","synthetic":true,"types":[]},{"text":"impl !Sync for DotDotEq","synthetic":true,"types":[]},{"text":"impl !Sync for Eq","synthetic":true,"types":[]},{"text":"impl !Sync for EqEq","synthetic":true,"types":[]},{"text":"impl !Sync for Ge","synthetic":true,"types":[]},{"text":"impl !Sync for Gt","synthetic":true,"types":[]},{"text":"impl !Sync for Le","synthetic":true,"types":[]},{"text":"impl !Sync for Lt","synthetic":true,"types":[]},{"text":"impl !Sync for MulEq","synthetic":true,"types":[]},{"text":"impl !Sync for Ne","synthetic":true,"types":[]},{"text":"impl !Sync for Or","synthetic":true,"types":[]},{"text":"impl !Sync for OrEq","synthetic":true,"types":[]},{"text":"impl !Sync for OrOr","synthetic":true,"types":[]},{"text":"impl !Sync for Pound","synthetic":true,"types":[]},{"text":"impl !Sync for Question","synthetic":true,"types":[]},{"text":"impl !Sync for RArrow","synthetic":true,"types":[]},{"text":"impl !Sync for LArrow","synthetic":true,"types":[]},{"text":"impl !Sync for Rem","synthetic":true,"types":[]},{"text":"impl !Sync for RemEq","synthetic":true,"types":[]},{"text":"impl !Sync for FatArrow","synthetic":true,"types":[]},{"text":"impl !Sync for Semi","synthetic":true,"types":[]},{"text":"impl !Sync for Shl","synthetic":true,"types":[]},{"text":"impl !Sync for ShlEq","synthetic":true,"types":[]},{"text":"impl !Sync for Shr","synthetic":true,"types":[]},{"text":"impl !Sync for ShrEq","synthetic":true,"types":[]},{"text":"impl !Sync for Star","synthetic":true,"types":[]},{"text":"impl !Sync for Sub","synthetic":true,"types":[]},{"text":"impl !Sync for SubEq","synthetic":true,"types":[]},{"text":"impl !Sync for Tilde","synthetic":true,"types":[]},{"text":"impl !Sync for Brace","synthetic":true,"types":[]},{"text":"impl !Sync for Bracket","synthetic":true,"types":[]},{"text":"impl !Sync for Paren","synthetic":true,"types":[]},{"text":"impl !Sync for Group","synthetic":true,"types":[]},{"text":"impl !Sync for Attribute","synthetic":true,"types":[]},{"text":"impl !Sync for AttrStyle","synthetic":true,"types":[]},{"text":"impl !Sync for Meta","synthetic":true,"types":[]},{"text":"impl !Sync for MetaList","synthetic":true,"types":[]},{"text":"impl !Sync for MetaNameValue","synthetic":true,"types":[]},{"text":"impl !Sync for NestedMeta","synthetic":true,"types":[]},{"text":"impl !Sync for Variant","synthetic":true,"types":[]},{"text":"impl !Sync for Fields","synthetic":true,"types":[]},{"text":"impl !Sync for FieldsNamed","synthetic":true,"types":[]},{"text":"impl !Sync for FieldsUnnamed","synthetic":true,"types":[]},{"text":"impl !Sync for Field","synthetic":true,"types":[]},{"text":"impl !Sync for Visibility","synthetic":true,"types":[]},{"text":"impl !Sync for VisPublic","synthetic":true,"types":[]},{"text":"impl !Sync for VisCrate","synthetic":true,"types":[]},{"text":"impl !Sync for VisRestricted","synthetic":true,"types":[]},{"text":"impl !Sync for Expr","synthetic":true,"types":[]},{"text":"impl !Sync for ExprArray","synthetic":true,"types":[]},{"text":"impl !Sync for ExprAssign","synthetic":true,"types":[]},{"text":"impl !Sync for ExprAssignOp","synthetic":true,"types":[]},{"text":"impl !Sync for ExprAsync","synthetic":true,"types":[]},{"text":"impl !Sync for ExprAwait","synthetic":true,"types":[]},{"text":"impl !Sync for ExprBinary","synthetic":true,"types":[]},{"text":"impl !Sync for ExprBlock","synthetic":true,"types":[]},{"text":"impl !Sync for ExprBox","synthetic":true,"types":[]},{"text":"impl !Sync for ExprBreak","synthetic":true,"types":[]},{"text":"impl !Sync for ExprCall","synthetic":true,"types":[]},{"text":"impl !Sync for ExprCast","synthetic":true,"types":[]},{"text":"impl !Sync for ExprClosure","synthetic":true,"types":[]},{"text":"impl !Sync for ExprContinue","synthetic":true,"types":[]},{"text":"impl !Sync for ExprField","synthetic":true,"types":[]},{"text":"impl !Sync for ExprForLoop","synthetic":true,"types":[]},{"text":"impl !Sync for ExprGroup","synthetic":true,"types":[]},{"text":"impl !Sync for ExprIf","synthetic":true,"types":[]},{"text":"impl !Sync for ExprIndex","synthetic":true,"types":[]},{"text":"impl !Sync for ExprLet","synthetic":true,"types":[]},{"text":"impl !Sync for ExprLit","synthetic":true,"types":[]},{"text":"impl !Sync for ExprLoop","synthetic":true,"types":[]},{"text":"impl !Sync for ExprMacro","synthetic":true,"types":[]},{"text":"impl !Sync for ExprMatch","synthetic":true,"types":[]},{"text":"impl !Sync for ExprMethodCall","synthetic":true,"types":[]},{"text":"impl !Sync for ExprParen","synthetic":true,"types":[]},{"text":"impl !Sync for ExprPath","synthetic":true,"types":[]},{"text":"impl !Sync for ExprRange","synthetic":true,"types":[]},{"text":"impl !Sync for ExprReference","synthetic":true,"types":[]},{"text":"impl !Sync for ExprRepeat","synthetic":true,"types":[]},{"text":"impl !Sync for ExprReturn","synthetic":true,"types":[]},{"text":"impl !Sync for ExprStruct","synthetic":true,"types":[]},{"text":"impl !Sync for ExprTry","synthetic":true,"types":[]},{"text":"impl !Sync for ExprTryBlock","synthetic":true,"types":[]},{"text":"impl !Sync for ExprTuple","synthetic":true,"types":[]},{"text":"impl !Sync for ExprType","synthetic":true,"types":[]},{"text":"impl !Sync for ExprUnary","synthetic":true,"types":[]},{"text":"impl !Sync for ExprUnsafe","synthetic":true,"types":[]},{"text":"impl !Sync for ExprWhile","synthetic":true,"types":[]},{"text":"impl !Sync for ExprYield","synthetic":true,"types":[]},{"text":"impl !Sync for Member","synthetic":true,"types":[]},{"text":"impl !Sync for Index","synthetic":true,"types":[]},{"text":"impl !Sync for Generics","synthetic":true,"types":[]},{"text":"impl !Sync for GenericParam","synthetic":true,"types":[]},{"text":"impl !Sync for TypeParam","synthetic":true,"types":[]},{"text":"impl !Sync for LifetimeDef","synthetic":true,"types":[]},{"text":"impl !Sync for ConstParam","synthetic":true,"types":[]},{"text":"impl<'a> !Sync for ImplGenerics<'a>","synthetic":true,"types":[]},{"text":"impl<'a> !Sync for TypeGenerics<'a>","synthetic":true,"types":[]},{"text":"impl<'a> !Sync for Turbofish<'a>","synthetic":true,"types":[]},{"text":"impl !Sync for BoundLifetimes","synthetic":true,"types":[]},{"text":"impl !Sync for TypeParamBound","synthetic":true,"types":[]},{"text":"impl !Sync for TraitBound","synthetic":true,"types":[]},{"text":"impl !Sync for TraitBoundModifier","synthetic":true,"types":[]},{"text":"impl !Sync for WhereClause","synthetic":true,"types":[]},{"text":"impl !Sync for WherePredicate","synthetic":true,"types":[]},{"text":"impl !Sync for PredicateType","synthetic":true,"types":[]},{"text":"impl !Sync for PredicateLifetime","synthetic":true,"types":[]},{"text":"impl !Sync for PredicateEq","synthetic":true,"types":[]},{"text":"impl !Sync for Lifetime","synthetic":true,"types":[]},{"text":"impl !Sync for Lit","synthetic":true,"types":[]},{"text":"impl !Sync for LitStr","synthetic":true,"types":[]},{"text":"impl !Sync for LitByteStr","synthetic":true,"types":[]},{"text":"impl !Sync for LitByte","synthetic":true,"types":[]},{"text":"impl !Sync for LitChar","synthetic":true,"types":[]},{"text":"impl !Sync for LitInt","synthetic":true,"types":[]},{"text":"impl !Sync for LitFloat","synthetic":true,"types":[]},{"text":"impl !Sync for LitBool","synthetic":true,"types":[]},{"text":"impl Sync for StrStyle","synthetic":true,"types":[]},{"text":"impl !Sync for Macro","synthetic":true,"types":[]},{"text":"impl !Sync for MacroDelimiter","synthetic":true,"types":[]},{"text":"impl !Sync for DeriveInput","synthetic":true,"types":[]},{"text":"impl !Sync for Data","synthetic":true,"types":[]},{"text":"impl !Sync for DataStruct","synthetic":true,"types":[]},{"text":"impl !Sync for DataEnum","synthetic":true,"types":[]},{"text":"impl !Sync for DataUnion","synthetic":true,"types":[]},{"text":"impl !Sync for BinOp","synthetic":true,"types":[]},{"text":"impl !Sync for UnOp","synthetic":true,"types":[]},{"text":"impl !Sync for Type","synthetic":true,"types":[]},{"text":"impl !Sync for TypeArray","synthetic":true,"types":[]},{"text":"impl !Sync for TypeBareFn","synthetic":true,"types":[]},{"text":"impl !Sync for TypeGroup","synthetic":true,"types":[]},{"text":"impl !Sync for TypeImplTrait","synthetic":true,"types":[]},{"text":"impl !Sync for TypeInfer","synthetic":true,"types":[]},{"text":"impl !Sync for TypeMacro","synthetic":true,"types":[]},{"text":"impl !Sync for TypeNever","synthetic":true,"types":[]},{"text":"impl !Sync for TypeParen","synthetic":true,"types":[]},{"text":"impl !Sync for TypePath","synthetic":true,"types":[]},{"text":"impl !Sync for TypePtr","synthetic":true,"types":[]},{"text":"impl !Sync for TypeReference","synthetic":true,"types":[]},{"text":"impl !Sync for TypeSlice","synthetic":true,"types":[]},{"text":"impl !Sync for TypeTraitObject","synthetic":true,"types":[]},{"text":"impl !Sync for TypeTuple","synthetic":true,"types":[]},{"text":"impl !Sync for Abi","synthetic":true,"types":[]},{"text":"impl !Sync for BareFnArg","synthetic":true,"types":[]},{"text":"impl !Sync for Variadic","synthetic":true,"types":[]},{"text":"impl !Sync for ReturnType","synthetic":true,"types":[]},{"text":"impl !Sync for Path","synthetic":true,"types":[]},{"text":"impl !Sync for PathSegment","synthetic":true,"types":[]},{"text":"impl !Sync for PathArguments","synthetic":true,"types":[]},{"text":"impl !Sync for GenericArgument","synthetic":true,"types":[]},{"text":"impl !Sync for AngleBracketedGenericArguments","synthetic":true,"types":[]},{"text":"impl !Sync for Binding","synthetic":true,"types":[]},{"text":"impl !Sync for Constraint","synthetic":true,"types":[]},{"text":"impl !Sync for ParenthesizedGenericArguments","synthetic":true,"types":[]},{"text":"impl !Sync for QSelf","synthetic":true,"types":[]},{"text":"impl !Sync for TokenBuffer","synthetic":true,"types":[]},{"text":"impl<'a> !Sync for Cursor<'a>","synthetic":true,"types":[]},{"text":"impl<T, P> Sync for Punctuated<T, P> where
    P: Sync,
    T: Sync, ","synthetic":true,"types":[]},{"text":"impl<'a, T, P> Sync for Pairs<'a, T, P> where
    P: Sync,
    T: Sync, ","synthetic":true,"types":[]},{"text":"impl<'a, T, P> Sync for PairsMut<'a, T, P> where
    P: Sync,
    T: Sync, ","synthetic":true,"types":[]},{"text":"impl<T, P> Sync for IntoPairs<T, P> where
    P: Sync,
    T: Sync, ","synthetic":true,"types":[]},{"text":"impl<T> Sync for IntoIter<T> where
    T: Sync, ","synthetic":true,"types":[]},{"text":"impl<'a, T> !Sync for Iter<'a, T>","synthetic":true,"types":[]},{"text":"impl<'a, T> !Sync for IterMut<'a, T>","synthetic":true,"types":[]},{"text":"impl<T, P> Sync for Pair<T, P> where
    P: Sync,
    T: Sync, ","synthetic":true,"types":[]},{"text":"impl<'a> !Sync for Lookahead1<'a>","synthetic":true,"types":[]},{"text":"impl Sync for Error","synthetic":true,"types":[]},{"text":"impl<'a> !Sync for ParseBuffer<'a>","synthetic":true,"types":[]},{"text":"impl<'c, 'a> !Sync for StepCursor<'c, 'a>","synthetic":true,"types":[]},{"text":"impl Sync for Nothing","synthetic":true,"types":[]}]; -implementors["synstructure"] = [{"text":"impl Sync for AddBounds","synthetic":true,"types":[]},{"text":"impl Sync for BindStyle","synthetic":true,"types":[]},{"text":"impl<'a> !Sync for BindingInfo<'a>","synthetic":true,"types":[]},{"text":"impl<'a> !Sync for VariantAst<'a>","synthetic":true,"types":[]},{"text":"impl<'a> !Sync for VariantInfo<'a>","synthetic":true,"types":[]},{"text":"impl<'a> !Sync for Structure<'a>","synthetic":true,"types":[]}]; +implementors["delog"] = [{"text":"impl Sync for U1","synthetic":true,"types":["delog::hex::U1"]},{"text":"impl<'a, T: ?Sized, U, S> Sync for HexStr<'a, T, U, S> where
    S: Sync,
    T: Sync,
    U: Sync, ","synthetic":true,"types":["delog::hex::HexStr"]},{"text":"impl Sync for Statistics","synthetic":true,"types":["delog::logger::Statistics"]},{"text":"impl Sync for RipgrepRenderer","synthetic":true,"types":["delog::render::RipgrepRenderer"]},{"text":"impl Sync for DefaultRenderer","synthetic":false,"types":["delog::render::DefaultRenderer"]}]; +implementors["flexiber"] = [{"text":"impl<'a> Sync for Decoder<'a>","synthetic":true,"types":["flexiber::decoder::Decoder"]},{"text":"impl<'a> Sync for Encoder<'a>","synthetic":true,"types":["flexiber::encoder::Encoder"]},{"text":"impl Sync for Error","synthetic":true,"types":["flexiber::error::Error"]},{"text":"impl Sync for ErrorKind","synthetic":true,"types":["flexiber::error::ErrorKind"]},{"text":"impl Sync for Length","synthetic":true,"types":["flexiber::length::Length"]},{"text":"impl Sync for SimpleTag","synthetic":true,"types":["flexiber::simpletag::SimpleTag"]},{"text":"impl<'a> Sync for Slice<'a>","synthetic":true,"types":["flexiber::slice::Slice"]},{"text":"impl Sync for Class","synthetic":true,"types":["flexiber::tag::Class"]},{"text":"impl Sync for Tag","synthetic":true,"types":["flexiber::tag::Tag"]},{"text":"impl<V, T> Sync for TaggedValue<V, T> where
    T: Sync,
    V: Sync, ","synthetic":true,"types":["flexiber::tagged::TaggedValue"]}]; +implementors["log"] = [{"text":"impl Sync for Level","synthetic":true,"types":["log::Level"]},{"text":"impl Sync for LevelFilter","synthetic":true,"types":["log::LevelFilter"]},{"text":"impl<'a> !Sync for Record<'a>","synthetic":true,"types":["log::Record"]},{"text":"impl<'a> !Sync for RecordBuilder<'a>","synthetic":true,"types":["log::RecordBuilder"]},{"text":"impl<'a> Sync for Metadata<'a>","synthetic":true,"types":["log::Metadata"]},{"text":"impl<'a> Sync for MetadataBuilder<'a>","synthetic":true,"types":["log::MetadataBuilder"]},{"text":"impl Sync for SetLoggerError","synthetic":true,"types":["log::SetLoggerError"]},{"text":"impl Sync for ParseLevelError","synthetic":true,"types":["log::ParseLevelError"]}]; +implementors["proc_macro2"] = [{"text":"impl !Sync for IntoIter","synthetic":true,"types":["proc_macro2::token_stream::IntoIter"]},{"text":"impl !Sync for TokenStream","synthetic":true,"types":["proc_macro2::TokenStream"]},{"text":"impl !Sync for LexError","synthetic":true,"types":["proc_macro2::LexError"]},{"text":"impl !Sync for Span","synthetic":true,"types":["proc_macro2::Span"]},{"text":"impl !Sync for TokenTree","synthetic":true,"types":["proc_macro2::TokenTree"]},{"text":"impl !Sync for Group","synthetic":true,"types":["proc_macro2::Group"]},{"text":"impl Sync for Delimiter","synthetic":true,"types":["proc_macro2::Delimiter"]},{"text":"impl !Sync for Punct","synthetic":true,"types":["proc_macro2::Punct"]},{"text":"impl Sync for Spacing","synthetic":true,"types":["proc_macro2::Spacing"]},{"text":"impl !Sync for Ident","synthetic":true,"types":["proc_macro2::Ident"]},{"text":"impl !Sync for Literal","synthetic":true,"types":["proc_macro2::Literal"]}]; +implementors["syn"] = [{"text":"impl !Sync for Underscore","synthetic":true,"types":["syn::token::Underscore"]},{"text":"impl !Sync for Abstract","synthetic":true,"types":["syn::token::Abstract"]},{"text":"impl !Sync for As","synthetic":true,"types":["syn::token::As"]},{"text":"impl !Sync for Async","synthetic":true,"types":["syn::token::Async"]},{"text":"impl !Sync for Auto","synthetic":true,"types":["syn::token::Auto"]},{"text":"impl !Sync for Await","synthetic":true,"types":["syn::token::Await"]},{"text":"impl !Sync for Become","synthetic":true,"types":["syn::token::Become"]},{"text":"impl !Sync for Box","synthetic":true,"types":["syn::token::Box"]},{"text":"impl !Sync for Break","synthetic":true,"types":["syn::token::Break"]},{"text":"impl !Sync for Const","synthetic":true,"types":["syn::token::Const"]},{"text":"impl !Sync for Continue","synthetic":true,"types":["syn::token::Continue"]},{"text":"impl !Sync for Crate","synthetic":true,"types":["syn::token::Crate"]},{"text":"impl !Sync for Default","synthetic":true,"types":["syn::token::Default"]},{"text":"impl !Sync for Do","synthetic":true,"types":["syn::token::Do"]},{"text":"impl !Sync for Dyn","synthetic":true,"types":["syn::token::Dyn"]},{"text":"impl !Sync for Else","synthetic":true,"types":["syn::token::Else"]},{"text":"impl !Sync for Enum","synthetic":true,"types":["syn::token::Enum"]},{"text":"impl !Sync for Extern","synthetic":true,"types":["syn::token::Extern"]},{"text":"impl !Sync for Final","synthetic":true,"types":["syn::token::Final"]},{"text":"impl !Sync for Fn","synthetic":true,"types":["syn::token::Fn"]},{"text":"impl !Sync for For","synthetic":true,"types":["syn::token::For"]},{"text":"impl !Sync for If","synthetic":true,"types":["syn::token::If"]},{"text":"impl !Sync for Impl","synthetic":true,"types":["syn::token::Impl"]},{"text":"impl !Sync for In","synthetic":true,"types":["syn::token::In"]},{"text":"impl !Sync for Let","synthetic":true,"types":["syn::token::Let"]},{"text":"impl !Sync for Loop","synthetic":true,"types":["syn::token::Loop"]},{"text":"impl !Sync for Macro","synthetic":true,"types":["syn::token::Macro"]},{"text":"impl !Sync for Match","synthetic":true,"types":["syn::token::Match"]},{"text":"impl !Sync for Mod","synthetic":true,"types":["syn::token::Mod"]},{"text":"impl !Sync for Move","synthetic":true,"types":["syn::token::Move"]},{"text":"impl !Sync for Mut","synthetic":true,"types":["syn::token::Mut"]},{"text":"impl !Sync for Override","synthetic":true,"types":["syn::token::Override"]},{"text":"impl !Sync for Priv","synthetic":true,"types":["syn::token::Priv"]},{"text":"impl !Sync for Pub","synthetic":true,"types":["syn::token::Pub"]},{"text":"impl !Sync for Ref","synthetic":true,"types":["syn::token::Ref"]},{"text":"impl !Sync for Return","synthetic":true,"types":["syn::token::Return"]},{"text":"impl !Sync for SelfType","synthetic":true,"types":["syn::token::SelfType"]},{"text":"impl !Sync for SelfValue","synthetic":true,"types":["syn::token::SelfValue"]},{"text":"impl !Sync for Static","synthetic":true,"types":["syn::token::Static"]},{"text":"impl !Sync for Struct","synthetic":true,"types":["syn::token::Struct"]},{"text":"impl !Sync for Super","synthetic":true,"types":["syn::token::Super"]},{"text":"impl !Sync for Trait","synthetic":true,"types":["syn::token::Trait"]},{"text":"impl !Sync for Try","synthetic":true,"types":["syn::token::Try"]},{"text":"impl !Sync for Type","synthetic":true,"types":["syn::token::Type"]},{"text":"impl !Sync for Typeof","synthetic":true,"types":["syn::token::Typeof"]},{"text":"impl !Sync for Union","synthetic":true,"types":["syn::token::Union"]},{"text":"impl !Sync for Unsafe","synthetic":true,"types":["syn::token::Unsafe"]},{"text":"impl !Sync for Unsized","synthetic":true,"types":["syn::token::Unsized"]},{"text":"impl !Sync for Use","synthetic":true,"types":["syn::token::Use"]},{"text":"impl !Sync for Virtual","synthetic":true,"types":["syn::token::Virtual"]},{"text":"impl !Sync for Where","synthetic":true,"types":["syn::token::Where"]},{"text":"impl !Sync for While","synthetic":true,"types":["syn::token::While"]},{"text":"impl !Sync for Yield","synthetic":true,"types":["syn::token::Yield"]},{"text":"impl !Sync for Add","synthetic":true,"types":["syn::token::Add"]},{"text":"impl !Sync for AddEq","synthetic":true,"types":["syn::token::AddEq"]},{"text":"impl !Sync for And","synthetic":true,"types":["syn::token::And"]},{"text":"impl !Sync for AndAnd","synthetic":true,"types":["syn::token::AndAnd"]},{"text":"impl !Sync for AndEq","synthetic":true,"types":["syn::token::AndEq"]},{"text":"impl !Sync for At","synthetic":true,"types":["syn::token::At"]},{"text":"impl !Sync for Bang","synthetic":true,"types":["syn::token::Bang"]},{"text":"impl !Sync for Caret","synthetic":true,"types":["syn::token::Caret"]},{"text":"impl !Sync for CaretEq","synthetic":true,"types":["syn::token::CaretEq"]},{"text":"impl !Sync for Colon","synthetic":true,"types":["syn::token::Colon"]},{"text":"impl !Sync for Colon2","synthetic":true,"types":["syn::token::Colon2"]},{"text":"impl !Sync for Comma","synthetic":true,"types":["syn::token::Comma"]},{"text":"impl !Sync for Div","synthetic":true,"types":["syn::token::Div"]},{"text":"impl !Sync for DivEq","synthetic":true,"types":["syn::token::DivEq"]},{"text":"impl !Sync for Dollar","synthetic":true,"types":["syn::token::Dollar"]},{"text":"impl !Sync for Dot","synthetic":true,"types":["syn::token::Dot"]},{"text":"impl !Sync for Dot2","synthetic":true,"types":["syn::token::Dot2"]},{"text":"impl !Sync for Dot3","synthetic":true,"types":["syn::token::Dot3"]},{"text":"impl !Sync for DotDotEq","synthetic":true,"types":["syn::token::DotDotEq"]},{"text":"impl !Sync for Eq","synthetic":true,"types":["syn::token::Eq"]},{"text":"impl !Sync for EqEq","synthetic":true,"types":["syn::token::EqEq"]},{"text":"impl !Sync for Ge","synthetic":true,"types":["syn::token::Ge"]},{"text":"impl !Sync for Gt","synthetic":true,"types":["syn::token::Gt"]},{"text":"impl !Sync for Le","synthetic":true,"types":["syn::token::Le"]},{"text":"impl !Sync for Lt","synthetic":true,"types":["syn::token::Lt"]},{"text":"impl !Sync for MulEq","synthetic":true,"types":["syn::token::MulEq"]},{"text":"impl !Sync for Ne","synthetic":true,"types":["syn::token::Ne"]},{"text":"impl !Sync for Or","synthetic":true,"types":["syn::token::Or"]},{"text":"impl !Sync for OrEq","synthetic":true,"types":["syn::token::OrEq"]},{"text":"impl !Sync for OrOr","synthetic":true,"types":["syn::token::OrOr"]},{"text":"impl !Sync for Pound","synthetic":true,"types":["syn::token::Pound"]},{"text":"impl !Sync for Question","synthetic":true,"types":["syn::token::Question"]},{"text":"impl !Sync for RArrow","synthetic":true,"types":["syn::token::RArrow"]},{"text":"impl !Sync for LArrow","synthetic":true,"types":["syn::token::LArrow"]},{"text":"impl !Sync for Rem","synthetic":true,"types":["syn::token::Rem"]},{"text":"impl !Sync for RemEq","synthetic":true,"types":["syn::token::RemEq"]},{"text":"impl !Sync for FatArrow","synthetic":true,"types":["syn::token::FatArrow"]},{"text":"impl !Sync for Semi","synthetic":true,"types":["syn::token::Semi"]},{"text":"impl !Sync for Shl","synthetic":true,"types":["syn::token::Shl"]},{"text":"impl !Sync for ShlEq","synthetic":true,"types":["syn::token::ShlEq"]},{"text":"impl !Sync for Shr","synthetic":true,"types":["syn::token::Shr"]},{"text":"impl !Sync for ShrEq","synthetic":true,"types":["syn::token::ShrEq"]},{"text":"impl !Sync for Star","synthetic":true,"types":["syn::token::Star"]},{"text":"impl !Sync for Sub","synthetic":true,"types":["syn::token::Sub"]},{"text":"impl !Sync for SubEq","synthetic":true,"types":["syn::token::SubEq"]},{"text":"impl !Sync for Tilde","synthetic":true,"types":["syn::token::Tilde"]},{"text":"impl !Sync for Brace","synthetic":true,"types":["syn::token::Brace"]},{"text":"impl !Sync for Bracket","synthetic":true,"types":["syn::token::Bracket"]},{"text":"impl !Sync for Paren","synthetic":true,"types":["syn::token::Paren"]},{"text":"impl !Sync for Group","synthetic":true,"types":["syn::token::Group"]},{"text":"impl !Sync for Attribute","synthetic":true,"types":["syn::attr::Attribute"]},{"text":"impl !Sync for AttrStyle","synthetic":true,"types":["syn::attr::AttrStyle"]},{"text":"impl !Sync for Meta","synthetic":true,"types":["syn::attr::Meta"]},{"text":"impl !Sync for MetaList","synthetic":true,"types":["syn::attr::MetaList"]},{"text":"impl !Sync for MetaNameValue","synthetic":true,"types":["syn::attr::MetaNameValue"]},{"text":"impl !Sync for NestedMeta","synthetic":true,"types":["syn::attr::NestedMeta"]},{"text":"impl !Sync for Variant","synthetic":true,"types":["syn::data::Variant"]},{"text":"impl !Sync for Fields","synthetic":true,"types":["syn::data::Fields"]},{"text":"impl !Sync for FieldsNamed","synthetic":true,"types":["syn::data::FieldsNamed"]},{"text":"impl !Sync for FieldsUnnamed","synthetic":true,"types":["syn::data::FieldsUnnamed"]},{"text":"impl !Sync for Field","synthetic":true,"types":["syn::data::Field"]},{"text":"impl !Sync for Visibility","synthetic":true,"types":["syn::data::Visibility"]},{"text":"impl !Sync for VisPublic","synthetic":true,"types":["syn::data::VisPublic"]},{"text":"impl !Sync for VisCrate","synthetic":true,"types":["syn::data::VisCrate"]},{"text":"impl !Sync for VisRestricted","synthetic":true,"types":["syn::data::VisRestricted"]},{"text":"impl !Sync for Expr","synthetic":true,"types":["syn::expr::Expr"]},{"text":"impl !Sync for ExprArray","synthetic":true,"types":["syn::expr::ExprArray"]},{"text":"impl !Sync for ExprAssign","synthetic":true,"types":["syn::expr::ExprAssign"]},{"text":"impl !Sync for ExprAssignOp","synthetic":true,"types":["syn::expr::ExprAssignOp"]},{"text":"impl !Sync for ExprAsync","synthetic":true,"types":["syn::expr::ExprAsync"]},{"text":"impl !Sync for ExprAwait","synthetic":true,"types":["syn::expr::ExprAwait"]},{"text":"impl !Sync for ExprBinary","synthetic":true,"types":["syn::expr::ExprBinary"]},{"text":"impl !Sync for ExprBlock","synthetic":true,"types":["syn::expr::ExprBlock"]},{"text":"impl !Sync for ExprBox","synthetic":true,"types":["syn::expr::ExprBox"]},{"text":"impl !Sync for ExprBreak","synthetic":true,"types":["syn::expr::ExprBreak"]},{"text":"impl !Sync for ExprCall","synthetic":true,"types":["syn::expr::ExprCall"]},{"text":"impl !Sync for ExprCast","synthetic":true,"types":["syn::expr::ExprCast"]},{"text":"impl !Sync for ExprClosure","synthetic":true,"types":["syn::expr::ExprClosure"]},{"text":"impl !Sync for ExprContinue","synthetic":true,"types":["syn::expr::ExprContinue"]},{"text":"impl !Sync for ExprField","synthetic":true,"types":["syn::expr::ExprField"]},{"text":"impl !Sync for ExprForLoop","synthetic":true,"types":["syn::expr::ExprForLoop"]},{"text":"impl !Sync for ExprGroup","synthetic":true,"types":["syn::expr::ExprGroup"]},{"text":"impl !Sync for ExprIf","synthetic":true,"types":["syn::expr::ExprIf"]},{"text":"impl !Sync for ExprIndex","synthetic":true,"types":["syn::expr::ExprIndex"]},{"text":"impl !Sync for ExprLet","synthetic":true,"types":["syn::expr::ExprLet"]},{"text":"impl !Sync for ExprLit","synthetic":true,"types":["syn::expr::ExprLit"]},{"text":"impl !Sync for ExprLoop","synthetic":true,"types":["syn::expr::ExprLoop"]},{"text":"impl !Sync for ExprMacro","synthetic":true,"types":["syn::expr::ExprMacro"]},{"text":"impl !Sync for ExprMatch","synthetic":true,"types":["syn::expr::ExprMatch"]},{"text":"impl !Sync for ExprMethodCall","synthetic":true,"types":["syn::expr::ExprMethodCall"]},{"text":"impl !Sync for ExprParen","synthetic":true,"types":["syn::expr::ExprParen"]},{"text":"impl !Sync for ExprPath","synthetic":true,"types":["syn::expr::ExprPath"]},{"text":"impl !Sync for ExprRange","synthetic":true,"types":["syn::expr::ExprRange"]},{"text":"impl !Sync for ExprReference","synthetic":true,"types":["syn::expr::ExprReference"]},{"text":"impl !Sync for ExprRepeat","synthetic":true,"types":["syn::expr::ExprRepeat"]},{"text":"impl !Sync for ExprReturn","synthetic":true,"types":["syn::expr::ExprReturn"]},{"text":"impl !Sync for ExprStruct","synthetic":true,"types":["syn::expr::ExprStruct"]},{"text":"impl !Sync for ExprTry","synthetic":true,"types":["syn::expr::ExprTry"]},{"text":"impl !Sync for ExprTryBlock","synthetic":true,"types":["syn::expr::ExprTryBlock"]},{"text":"impl !Sync for ExprTuple","synthetic":true,"types":["syn::expr::ExprTuple"]},{"text":"impl !Sync for ExprType","synthetic":true,"types":["syn::expr::ExprType"]},{"text":"impl !Sync for ExprUnary","synthetic":true,"types":["syn::expr::ExprUnary"]},{"text":"impl !Sync for ExprUnsafe","synthetic":true,"types":["syn::expr::ExprUnsafe"]},{"text":"impl !Sync for ExprWhile","synthetic":true,"types":["syn::expr::ExprWhile"]},{"text":"impl !Sync for ExprYield","synthetic":true,"types":["syn::expr::ExprYield"]},{"text":"impl !Sync for Member","synthetic":true,"types":["syn::expr::Member"]},{"text":"impl !Sync for Index","synthetic":true,"types":["syn::expr::Index"]},{"text":"impl !Sync for Generics","synthetic":true,"types":["syn::generics::Generics"]},{"text":"impl !Sync for GenericParam","synthetic":true,"types":["syn::generics::GenericParam"]},{"text":"impl !Sync for TypeParam","synthetic":true,"types":["syn::generics::TypeParam"]},{"text":"impl !Sync for LifetimeDef","synthetic":true,"types":["syn::generics::LifetimeDef"]},{"text":"impl !Sync for ConstParam","synthetic":true,"types":["syn::generics::ConstParam"]},{"text":"impl<'a> !Sync for ImplGenerics<'a>","synthetic":true,"types":["syn::generics::ImplGenerics"]},{"text":"impl<'a> !Sync for TypeGenerics<'a>","synthetic":true,"types":["syn::generics::TypeGenerics"]},{"text":"impl<'a> !Sync for Turbofish<'a>","synthetic":true,"types":["syn::generics::Turbofish"]},{"text":"impl !Sync for BoundLifetimes","synthetic":true,"types":["syn::generics::BoundLifetimes"]},{"text":"impl !Sync for TypeParamBound","synthetic":true,"types":["syn::generics::TypeParamBound"]},{"text":"impl !Sync for TraitBound","synthetic":true,"types":["syn::generics::TraitBound"]},{"text":"impl !Sync for TraitBoundModifier","synthetic":true,"types":["syn::generics::TraitBoundModifier"]},{"text":"impl !Sync for WhereClause","synthetic":true,"types":["syn::generics::WhereClause"]},{"text":"impl !Sync for WherePredicate","synthetic":true,"types":["syn::generics::WherePredicate"]},{"text":"impl !Sync for PredicateType","synthetic":true,"types":["syn::generics::PredicateType"]},{"text":"impl !Sync for PredicateLifetime","synthetic":true,"types":["syn::generics::PredicateLifetime"]},{"text":"impl !Sync for PredicateEq","synthetic":true,"types":["syn::generics::PredicateEq"]},{"text":"impl !Sync for Lifetime","synthetic":true,"types":["syn::lifetime::Lifetime"]},{"text":"impl !Sync for Lit","synthetic":true,"types":["syn::lit::Lit"]},{"text":"impl !Sync for LitStr","synthetic":true,"types":["syn::lit::LitStr"]},{"text":"impl !Sync for LitByteStr","synthetic":true,"types":["syn::lit::LitByteStr"]},{"text":"impl !Sync for LitByte","synthetic":true,"types":["syn::lit::LitByte"]},{"text":"impl !Sync for LitChar","synthetic":true,"types":["syn::lit::LitChar"]},{"text":"impl !Sync for LitInt","synthetic":true,"types":["syn::lit::LitInt"]},{"text":"impl !Sync for LitFloat","synthetic":true,"types":["syn::lit::LitFloat"]},{"text":"impl !Sync for LitBool","synthetic":true,"types":["syn::lit::LitBool"]},{"text":"impl Sync for StrStyle","synthetic":true,"types":["syn::lit::StrStyle"]},{"text":"impl !Sync for Macro","synthetic":true,"types":["syn::mac::Macro"]},{"text":"impl !Sync for MacroDelimiter","synthetic":true,"types":["syn::mac::MacroDelimiter"]},{"text":"impl !Sync for DeriveInput","synthetic":true,"types":["syn::derive::DeriveInput"]},{"text":"impl !Sync for Data","synthetic":true,"types":["syn::derive::Data"]},{"text":"impl !Sync for DataStruct","synthetic":true,"types":["syn::derive::DataStruct"]},{"text":"impl !Sync for DataEnum","synthetic":true,"types":["syn::derive::DataEnum"]},{"text":"impl !Sync for DataUnion","synthetic":true,"types":["syn::derive::DataUnion"]},{"text":"impl !Sync for BinOp","synthetic":true,"types":["syn::op::BinOp"]},{"text":"impl !Sync for UnOp","synthetic":true,"types":["syn::op::UnOp"]},{"text":"impl !Sync for Type","synthetic":true,"types":["syn::ty::Type"]},{"text":"impl !Sync for TypeArray","synthetic":true,"types":["syn::ty::TypeArray"]},{"text":"impl !Sync for TypeBareFn","synthetic":true,"types":["syn::ty::TypeBareFn"]},{"text":"impl !Sync for TypeGroup","synthetic":true,"types":["syn::ty::TypeGroup"]},{"text":"impl !Sync for TypeImplTrait","synthetic":true,"types":["syn::ty::TypeImplTrait"]},{"text":"impl !Sync for TypeInfer","synthetic":true,"types":["syn::ty::TypeInfer"]},{"text":"impl !Sync for TypeMacro","synthetic":true,"types":["syn::ty::TypeMacro"]},{"text":"impl !Sync for TypeNever","synthetic":true,"types":["syn::ty::TypeNever"]},{"text":"impl !Sync for TypeParen","synthetic":true,"types":["syn::ty::TypeParen"]},{"text":"impl !Sync for TypePath","synthetic":true,"types":["syn::ty::TypePath"]},{"text":"impl !Sync for TypePtr","synthetic":true,"types":["syn::ty::TypePtr"]},{"text":"impl !Sync for TypeReference","synthetic":true,"types":["syn::ty::TypeReference"]},{"text":"impl !Sync for TypeSlice","synthetic":true,"types":["syn::ty::TypeSlice"]},{"text":"impl !Sync for TypeTraitObject","synthetic":true,"types":["syn::ty::TypeTraitObject"]},{"text":"impl !Sync for TypeTuple","synthetic":true,"types":["syn::ty::TypeTuple"]},{"text":"impl !Sync for Abi","synthetic":true,"types":["syn::ty::Abi"]},{"text":"impl !Sync for BareFnArg","synthetic":true,"types":["syn::ty::BareFnArg"]},{"text":"impl !Sync for Variadic","synthetic":true,"types":["syn::ty::Variadic"]},{"text":"impl !Sync for ReturnType","synthetic":true,"types":["syn::ty::ReturnType"]},{"text":"impl !Sync for Path","synthetic":true,"types":["syn::path::Path"]},{"text":"impl !Sync for PathSegment","synthetic":true,"types":["syn::path::PathSegment"]},{"text":"impl !Sync for PathArguments","synthetic":true,"types":["syn::path::PathArguments"]},{"text":"impl !Sync for GenericArgument","synthetic":true,"types":["syn::path::GenericArgument"]},{"text":"impl !Sync for AngleBracketedGenericArguments","synthetic":true,"types":["syn::path::AngleBracketedGenericArguments"]},{"text":"impl !Sync for Binding","synthetic":true,"types":["syn::path::Binding"]},{"text":"impl !Sync for Constraint","synthetic":true,"types":["syn::path::Constraint"]},{"text":"impl !Sync for ParenthesizedGenericArguments","synthetic":true,"types":["syn::path::ParenthesizedGenericArguments"]},{"text":"impl !Sync for QSelf","synthetic":true,"types":["syn::path::QSelf"]},{"text":"impl !Sync for TokenBuffer","synthetic":true,"types":["syn::buffer::TokenBuffer"]},{"text":"impl<'a> !Sync for Cursor<'a>","synthetic":true,"types":["syn::buffer::Cursor"]},{"text":"impl<T, P> Sync for Punctuated<T, P> where
    P: Sync,
    T: Sync, ","synthetic":true,"types":["syn::punctuated::Punctuated"]},{"text":"impl<'a, T, P> Sync for Pairs<'a, T, P> where
    P: Sync,
    T: Sync, ","synthetic":true,"types":["syn::punctuated::Pairs"]},{"text":"impl<'a, T, P> Sync for PairsMut<'a, T, P> where
    P: Sync,
    T: Sync, ","synthetic":true,"types":["syn::punctuated::PairsMut"]},{"text":"impl<T, P> Sync for IntoPairs<T, P> where
    P: Sync,
    T: Sync, ","synthetic":true,"types":["syn::punctuated::IntoPairs"]},{"text":"impl<T> Sync for IntoIter<T> where
    T: Sync, ","synthetic":true,"types":["syn::punctuated::IntoIter"]},{"text":"impl<'a, T> !Sync for Iter<'a, T>","synthetic":true,"types":["syn::punctuated::Iter"]},{"text":"impl<'a, T> !Sync for IterMut<'a, T>","synthetic":true,"types":["syn::punctuated::IterMut"]},{"text":"impl<T, P> Sync for Pair<T, P> where
    P: Sync,
    T: Sync, ","synthetic":true,"types":["syn::punctuated::Pair"]},{"text":"impl<'a> !Sync for Lookahead1<'a>","synthetic":true,"types":["syn::lookahead::Lookahead1"]},{"text":"impl Sync for Error","synthetic":true,"types":["syn::error::Error"]},{"text":"impl<'a> !Sync for ParseBuffer<'a>","synthetic":true,"types":["syn::parse::ParseBuffer"]},{"text":"impl<'c, 'a> !Sync for StepCursor<'c, 'a>","synthetic":true,"types":["syn::parse::StepCursor"]},{"text":"impl Sync for Nothing","synthetic":true,"types":["syn::parse::Nothing"]}]; +implementors["synstructure"] = [{"text":"impl Sync for AddBounds","synthetic":true,"types":["synstructure::AddBounds"]},{"text":"impl Sync for BindStyle","synthetic":true,"types":["synstructure::BindStyle"]},{"text":"impl<'a> !Sync for BindingInfo<'a>","synthetic":true,"types":["synstructure::BindingInfo"]},{"text":"impl<'a> !Sync for VariantAst<'a>","synthetic":true,"types":["synstructure::VariantAst"]},{"text":"impl<'a> !Sync for VariantInfo<'a>","synthetic":true,"types":["synstructure::VariantInfo"]},{"text":"impl<'a> !Sync for Structure<'a>","synthetic":true,"types":["synstructure::Structure"]}]; if (window.register_implementors) {window.register_implementors(implementors);} else {window.pending_implementors = implementors;}})() \ No newline at end of file diff --git a/implementors/core/marker/trait.Unpin.js b/implementors/core/marker/trait.Unpin.js index 63f95b0..f9dace2 100644 --- a/implementors/core/marker/trait.Unpin.js +++ b/implementors/core/marker/trait.Unpin.js @@ -1,8 +1,8 @@ (function() {var implementors = {}; -implementors["delog"] = [{"text":"impl Unpin for U1","synthetic":true,"types":[]},{"text":"impl<'a, T: ?Sized, U, S> Unpin for HexStr<'a, T, U, S> where
    S: Unpin,
    U: Unpin, ","synthetic":true,"types":[]},{"text":"impl Unpin for Statistics","synthetic":true,"types":[]},{"text":"impl Unpin for DefaultRenderer","synthetic":true,"types":[]},{"text":"impl Unpin for RipgrepRenderer","synthetic":true,"types":[]}]; -implementors["flexiber"] = [{"text":"impl<'a> Unpin for Decoder<'a>","synthetic":true,"types":[]},{"text":"impl<'a> Unpin for Encoder<'a>","synthetic":true,"types":[]},{"text":"impl Unpin for Error","synthetic":true,"types":[]},{"text":"impl Unpin for ErrorKind","synthetic":true,"types":[]},{"text":"impl Unpin for Length","synthetic":true,"types":[]},{"text":"impl Unpin for SimpleTag","synthetic":true,"types":[]},{"text":"impl<'a> Unpin for Slice<'a>","synthetic":true,"types":[]},{"text":"impl Unpin for Class","synthetic":true,"types":[]},{"text":"impl Unpin for Tag","synthetic":true,"types":[]},{"text":"impl<V, T> Unpin for TaggedValue<V, T> where
    T: Unpin,
    V: Unpin, ","synthetic":true,"types":[]}]; -implementors["log"] = [{"text":"impl Unpin for Level","synthetic":true,"types":[]},{"text":"impl Unpin for LevelFilter","synthetic":true,"types":[]},{"text":"impl<'a> Unpin for Record<'a>","synthetic":true,"types":[]},{"text":"impl<'a> Unpin for RecordBuilder<'a>","synthetic":true,"types":[]},{"text":"impl<'a> Unpin for Metadata<'a>","synthetic":true,"types":[]},{"text":"impl<'a> Unpin for MetadataBuilder<'a>","synthetic":true,"types":[]},{"text":"impl Unpin for SetLoggerError","synthetic":true,"types":[]},{"text":"impl Unpin for ParseLevelError","synthetic":true,"types":[]}]; -implementors["proc_macro2"] = [{"text":"impl Unpin for IntoIter","synthetic":true,"types":[]},{"text":"impl Unpin for TokenStream","synthetic":true,"types":[]},{"text":"impl Unpin for LexError","synthetic":true,"types":[]},{"text":"impl Unpin for Span","synthetic":true,"types":[]},{"text":"impl Unpin for TokenTree","synthetic":true,"types":[]},{"text":"impl Unpin for Group","synthetic":true,"types":[]},{"text":"impl Unpin for Delimiter","synthetic":true,"types":[]},{"text":"impl Unpin for Punct","synthetic":true,"types":[]},{"text":"impl Unpin for Spacing","synthetic":true,"types":[]},{"text":"impl Unpin for Ident","synthetic":true,"types":[]},{"text":"impl Unpin for Literal","synthetic":true,"types":[]}]; -implementors["syn"] = [{"text":"impl Unpin for Underscore","synthetic":true,"types":[]},{"text":"impl Unpin for Abstract","synthetic":true,"types":[]},{"text":"impl Unpin for As","synthetic":true,"types":[]},{"text":"impl Unpin for Async","synthetic":true,"types":[]},{"text":"impl Unpin for Auto","synthetic":true,"types":[]},{"text":"impl Unpin for Await","synthetic":true,"types":[]},{"text":"impl Unpin for Become","synthetic":true,"types":[]},{"text":"impl Unpin for Box","synthetic":true,"types":[]},{"text":"impl Unpin for Break","synthetic":true,"types":[]},{"text":"impl Unpin for Const","synthetic":true,"types":[]},{"text":"impl Unpin for Continue","synthetic":true,"types":[]},{"text":"impl Unpin for Crate","synthetic":true,"types":[]},{"text":"impl Unpin for Default","synthetic":true,"types":[]},{"text":"impl Unpin for Do","synthetic":true,"types":[]},{"text":"impl Unpin for Dyn","synthetic":true,"types":[]},{"text":"impl Unpin for Else","synthetic":true,"types":[]},{"text":"impl Unpin for Enum","synthetic":true,"types":[]},{"text":"impl Unpin for Extern","synthetic":true,"types":[]},{"text":"impl Unpin for Final","synthetic":true,"types":[]},{"text":"impl Unpin for Fn","synthetic":true,"types":[]},{"text":"impl Unpin for For","synthetic":true,"types":[]},{"text":"impl Unpin for If","synthetic":true,"types":[]},{"text":"impl Unpin for Impl","synthetic":true,"types":[]},{"text":"impl Unpin for In","synthetic":true,"types":[]},{"text":"impl Unpin for Let","synthetic":true,"types":[]},{"text":"impl Unpin for Loop","synthetic":true,"types":[]},{"text":"impl Unpin for Macro","synthetic":true,"types":[]},{"text":"impl Unpin for Match","synthetic":true,"types":[]},{"text":"impl Unpin for Mod","synthetic":true,"types":[]},{"text":"impl Unpin for Move","synthetic":true,"types":[]},{"text":"impl Unpin for Mut","synthetic":true,"types":[]},{"text":"impl Unpin for Override","synthetic":true,"types":[]},{"text":"impl Unpin for Priv","synthetic":true,"types":[]},{"text":"impl Unpin for Pub","synthetic":true,"types":[]},{"text":"impl Unpin for Ref","synthetic":true,"types":[]},{"text":"impl Unpin for Return","synthetic":true,"types":[]},{"text":"impl Unpin for SelfType","synthetic":true,"types":[]},{"text":"impl Unpin for SelfValue","synthetic":true,"types":[]},{"text":"impl Unpin for Static","synthetic":true,"types":[]},{"text":"impl Unpin for Struct","synthetic":true,"types":[]},{"text":"impl Unpin for Super","synthetic":true,"types":[]},{"text":"impl Unpin for Trait","synthetic":true,"types":[]},{"text":"impl Unpin for Try","synthetic":true,"types":[]},{"text":"impl Unpin for Type","synthetic":true,"types":[]},{"text":"impl Unpin for Typeof","synthetic":true,"types":[]},{"text":"impl Unpin for Union","synthetic":true,"types":[]},{"text":"impl Unpin for Unsafe","synthetic":true,"types":[]},{"text":"impl Unpin for Unsized","synthetic":true,"types":[]},{"text":"impl Unpin for Use","synthetic":true,"types":[]},{"text":"impl Unpin for Virtual","synthetic":true,"types":[]},{"text":"impl Unpin for Where","synthetic":true,"types":[]},{"text":"impl Unpin for While","synthetic":true,"types":[]},{"text":"impl Unpin for Yield","synthetic":true,"types":[]},{"text":"impl Unpin for Add","synthetic":true,"types":[]},{"text":"impl Unpin for AddEq","synthetic":true,"types":[]},{"text":"impl Unpin for And","synthetic":true,"types":[]},{"text":"impl Unpin for AndAnd","synthetic":true,"types":[]},{"text":"impl Unpin for AndEq","synthetic":true,"types":[]},{"text":"impl Unpin for At","synthetic":true,"types":[]},{"text":"impl Unpin for Bang","synthetic":true,"types":[]},{"text":"impl Unpin for Caret","synthetic":true,"types":[]},{"text":"impl Unpin for CaretEq","synthetic":true,"types":[]},{"text":"impl Unpin for Colon","synthetic":true,"types":[]},{"text":"impl Unpin for Colon2","synthetic":true,"types":[]},{"text":"impl Unpin for Comma","synthetic":true,"types":[]},{"text":"impl Unpin for Div","synthetic":true,"types":[]},{"text":"impl Unpin for DivEq","synthetic":true,"types":[]},{"text":"impl Unpin for Dollar","synthetic":true,"types":[]},{"text":"impl Unpin for Dot","synthetic":true,"types":[]},{"text":"impl Unpin for Dot2","synthetic":true,"types":[]},{"text":"impl Unpin for Dot3","synthetic":true,"types":[]},{"text":"impl Unpin for DotDotEq","synthetic":true,"types":[]},{"text":"impl Unpin for Eq","synthetic":true,"types":[]},{"text":"impl Unpin for EqEq","synthetic":true,"types":[]},{"text":"impl Unpin for Ge","synthetic":true,"types":[]},{"text":"impl Unpin for Gt","synthetic":true,"types":[]},{"text":"impl Unpin for Le","synthetic":true,"types":[]},{"text":"impl Unpin for Lt","synthetic":true,"types":[]},{"text":"impl Unpin for MulEq","synthetic":true,"types":[]},{"text":"impl Unpin for Ne","synthetic":true,"types":[]},{"text":"impl Unpin for Or","synthetic":true,"types":[]},{"text":"impl Unpin for OrEq","synthetic":true,"types":[]},{"text":"impl Unpin for OrOr","synthetic":true,"types":[]},{"text":"impl Unpin for Pound","synthetic":true,"types":[]},{"text":"impl Unpin for Question","synthetic":true,"types":[]},{"text":"impl Unpin for RArrow","synthetic":true,"types":[]},{"text":"impl Unpin for LArrow","synthetic":true,"types":[]},{"text":"impl Unpin for Rem","synthetic":true,"types":[]},{"text":"impl Unpin for RemEq","synthetic":true,"types":[]},{"text":"impl Unpin for FatArrow","synthetic":true,"types":[]},{"text":"impl Unpin for Semi","synthetic":true,"types":[]},{"text":"impl Unpin for Shl","synthetic":true,"types":[]},{"text":"impl Unpin for ShlEq","synthetic":true,"types":[]},{"text":"impl Unpin for Shr","synthetic":true,"types":[]},{"text":"impl Unpin for ShrEq","synthetic":true,"types":[]},{"text":"impl Unpin for Star","synthetic":true,"types":[]},{"text":"impl Unpin for Sub","synthetic":true,"types":[]},{"text":"impl Unpin for SubEq","synthetic":true,"types":[]},{"text":"impl Unpin for Tilde","synthetic":true,"types":[]},{"text":"impl Unpin for Brace","synthetic":true,"types":[]},{"text":"impl Unpin for Bracket","synthetic":true,"types":[]},{"text":"impl Unpin for Paren","synthetic":true,"types":[]},{"text":"impl Unpin for Group","synthetic":true,"types":[]},{"text":"impl Unpin for Attribute","synthetic":true,"types":[]},{"text":"impl Unpin for AttrStyle","synthetic":true,"types":[]},{"text":"impl Unpin for Meta","synthetic":true,"types":[]},{"text":"impl Unpin for MetaList","synthetic":true,"types":[]},{"text":"impl Unpin for MetaNameValue","synthetic":true,"types":[]},{"text":"impl Unpin for NestedMeta","synthetic":true,"types":[]},{"text":"impl Unpin for Variant","synthetic":true,"types":[]},{"text":"impl Unpin for Fields","synthetic":true,"types":[]},{"text":"impl Unpin for FieldsNamed","synthetic":true,"types":[]},{"text":"impl Unpin for FieldsUnnamed","synthetic":true,"types":[]},{"text":"impl Unpin for Field","synthetic":true,"types":[]},{"text":"impl Unpin for Visibility","synthetic":true,"types":[]},{"text":"impl Unpin for VisPublic","synthetic":true,"types":[]},{"text":"impl Unpin for VisCrate","synthetic":true,"types":[]},{"text":"impl Unpin for VisRestricted","synthetic":true,"types":[]},{"text":"impl Unpin for Expr","synthetic":true,"types":[]},{"text":"impl Unpin for ExprArray","synthetic":true,"types":[]},{"text":"impl Unpin for ExprAssign","synthetic":true,"types":[]},{"text":"impl Unpin for ExprAssignOp","synthetic":true,"types":[]},{"text":"impl Unpin for ExprAsync","synthetic":true,"types":[]},{"text":"impl Unpin for ExprAwait","synthetic":true,"types":[]},{"text":"impl Unpin for ExprBinary","synthetic":true,"types":[]},{"text":"impl Unpin for ExprBlock","synthetic":true,"types":[]},{"text":"impl Unpin for ExprBox","synthetic":true,"types":[]},{"text":"impl Unpin for ExprBreak","synthetic":true,"types":[]},{"text":"impl Unpin for ExprCall","synthetic":true,"types":[]},{"text":"impl Unpin for ExprCast","synthetic":true,"types":[]},{"text":"impl Unpin for ExprClosure","synthetic":true,"types":[]},{"text":"impl Unpin for ExprContinue","synthetic":true,"types":[]},{"text":"impl Unpin for ExprField","synthetic":true,"types":[]},{"text":"impl Unpin for ExprForLoop","synthetic":true,"types":[]},{"text":"impl Unpin for ExprGroup","synthetic":true,"types":[]},{"text":"impl Unpin for ExprIf","synthetic":true,"types":[]},{"text":"impl Unpin for ExprIndex","synthetic":true,"types":[]},{"text":"impl Unpin for ExprLet","synthetic":true,"types":[]},{"text":"impl Unpin for ExprLit","synthetic":true,"types":[]},{"text":"impl Unpin for ExprLoop","synthetic":true,"types":[]},{"text":"impl Unpin for ExprMacro","synthetic":true,"types":[]},{"text":"impl Unpin for ExprMatch","synthetic":true,"types":[]},{"text":"impl Unpin for ExprMethodCall","synthetic":true,"types":[]},{"text":"impl Unpin for ExprParen","synthetic":true,"types":[]},{"text":"impl Unpin for ExprPath","synthetic":true,"types":[]},{"text":"impl Unpin for ExprRange","synthetic":true,"types":[]},{"text":"impl Unpin for ExprReference","synthetic":true,"types":[]},{"text":"impl Unpin for ExprRepeat","synthetic":true,"types":[]},{"text":"impl Unpin for ExprReturn","synthetic":true,"types":[]},{"text":"impl Unpin for ExprStruct","synthetic":true,"types":[]},{"text":"impl Unpin for ExprTry","synthetic":true,"types":[]},{"text":"impl Unpin for ExprTryBlock","synthetic":true,"types":[]},{"text":"impl Unpin for ExprTuple","synthetic":true,"types":[]},{"text":"impl Unpin for ExprType","synthetic":true,"types":[]},{"text":"impl Unpin for ExprUnary","synthetic":true,"types":[]},{"text":"impl Unpin for ExprUnsafe","synthetic":true,"types":[]},{"text":"impl Unpin for ExprWhile","synthetic":true,"types":[]},{"text":"impl Unpin for ExprYield","synthetic":true,"types":[]},{"text":"impl Unpin for Member","synthetic":true,"types":[]},{"text":"impl Unpin for Index","synthetic":true,"types":[]},{"text":"impl Unpin for Generics","synthetic":true,"types":[]},{"text":"impl Unpin for GenericParam","synthetic":true,"types":[]},{"text":"impl Unpin for TypeParam","synthetic":true,"types":[]},{"text":"impl Unpin for LifetimeDef","synthetic":true,"types":[]},{"text":"impl Unpin for ConstParam","synthetic":true,"types":[]},{"text":"impl<'a> Unpin for ImplGenerics<'a>","synthetic":true,"types":[]},{"text":"impl<'a> Unpin for TypeGenerics<'a>","synthetic":true,"types":[]},{"text":"impl<'a> Unpin for Turbofish<'a>","synthetic":true,"types":[]},{"text":"impl Unpin for BoundLifetimes","synthetic":true,"types":[]},{"text":"impl Unpin for TypeParamBound","synthetic":true,"types":[]},{"text":"impl Unpin for TraitBound","synthetic":true,"types":[]},{"text":"impl Unpin for TraitBoundModifier","synthetic":true,"types":[]},{"text":"impl Unpin for WhereClause","synthetic":true,"types":[]},{"text":"impl Unpin for WherePredicate","synthetic":true,"types":[]},{"text":"impl Unpin for PredicateType","synthetic":true,"types":[]},{"text":"impl Unpin for PredicateLifetime","synthetic":true,"types":[]},{"text":"impl Unpin for PredicateEq","synthetic":true,"types":[]},{"text":"impl Unpin for Lifetime","synthetic":true,"types":[]},{"text":"impl Unpin for Lit","synthetic":true,"types":[]},{"text":"impl Unpin for LitStr","synthetic":true,"types":[]},{"text":"impl Unpin for LitByteStr","synthetic":true,"types":[]},{"text":"impl Unpin for LitByte","synthetic":true,"types":[]},{"text":"impl Unpin for LitChar","synthetic":true,"types":[]},{"text":"impl Unpin for LitInt","synthetic":true,"types":[]},{"text":"impl Unpin for LitFloat","synthetic":true,"types":[]},{"text":"impl Unpin for LitBool","synthetic":true,"types":[]},{"text":"impl Unpin for StrStyle","synthetic":true,"types":[]},{"text":"impl Unpin for Macro","synthetic":true,"types":[]},{"text":"impl Unpin for MacroDelimiter","synthetic":true,"types":[]},{"text":"impl Unpin for DeriveInput","synthetic":true,"types":[]},{"text":"impl Unpin for Data","synthetic":true,"types":[]},{"text":"impl Unpin for DataStruct","synthetic":true,"types":[]},{"text":"impl Unpin for DataEnum","synthetic":true,"types":[]},{"text":"impl Unpin for DataUnion","synthetic":true,"types":[]},{"text":"impl Unpin for BinOp","synthetic":true,"types":[]},{"text":"impl Unpin for UnOp","synthetic":true,"types":[]},{"text":"impl Unpin for Type","synthetic":true,"types":[]},{"text":"impl Unpin for TypeArray","synthetic":true,"types":[]},{"text":"impl Unpin for TypeBareFn","synthetic":true,"types":[]},{"text":"impl Unpin for TypeGroup","synthetic":true,"types":[]},{"text":"impl Unpin for TypeImplTrait","synthetic":true,"types":[]},{"text":"impl Unpin for TypeInfer","synthetic":true,"types":[]},{"text":"impl Unpin for TypeMacro","synthetic":true,"types":[]},{"text":"impl Unpin for TypeNever","synthetic":true,"types":[]},{"text":"impl Unpin for TypeParen","synthetic":true,"types":[]},{"text":"impl Unpin for TypePath","synthetic":true,"types":[]},{"text":"impl Unpin for TypePtr","synthetic":true,"types":[]},{"text":"impl Unpin for TypeReference","synthetic":true,"types":[]},{"text":"impl Unpin for TypeSlice","synthetic":true,"types":[]},{"text":"impl Unpin for TypeTraitObject","synthetic":true,"types":[]},{"text":"impl Unpin for TypeTuple","synthetic":true,"types":[]},{"text":"impl Unpin for Abi","synthetic":true,"types":[]},{"text":"impl Unpin for BareFnArg","synthetic":true,"types":[]},{"text":"impl Unpin for Variadic","synthetic":true,"types":[]},{"text":"impl Unpin for ReturnType","synthetic":true,"types":[]},{"text":"impl Unpin for Path","synthetic":true,"types":[]},{"text":"impl Unpin for PathSegment","synthetic":true,"types":[]},{"text":"impl Unpin for PathArguments","synthetic":true,"types":[]},{"text":"impl Unpin for GenericArgument","synthetic":true,"types":[]},{"text":"impl Unpin for AngleBracketedGenericArguments","synthetic":true,"types":[]},{"text":"impl Unpin for Binding","synthetic":true,"types":[]},{"text":"impl Unpin for Constraint","synthetic":true,"types":[]},{"text":"impl Unpin for ParenthesizedGenericArguments","synthetic":true,"types":[]},{"text":"impl Unpin for QSelf","synthetic":true,"types":[]},{"text":"impl Unpin for TokenBuffer","synthetic":true,"types":[]},{"text":"impl<'a> Unpin for Cursor<'a>","synthetic":true,"types":[]},{"text":"impl<T, P> Unpin for Punctuated<T, P> where
    P: Unpin,
    T: Unpin, ","synthetic":true,"types":[]},{"text":"impl<'a, T, P> Unpin for Pairs<'a, T, P>","synthetic":true,"types":[]},{"text":"impl<'a, T, P> Unpin for PairsMut<'a, T, P>","synthetic":true,"types":[]},{"text":"impl<T, P> Unpin for IntoPairs<T, P> where
    P: Unpin,
    T: Unpin, ","synthetic":true,"types":[]},{"text":"impl<T> Unpin for IntoIter<T> where
    T: Unpin, ","synthetic":true,"types":[]},{"text":"impl<'a, T> Unpin for Iter<'a, T>","synthetic":true,"types":[]},{"text":"impl<'a, T> Unpin for IterMut<'a, T>","synthetic":true,"types":[]},{"text":"impl<T, P> Unpin for Pair<T, P> where
    P: Unpin,
    T: Unpin, ","synthetic":true,"types":[]},{"text":"impl<'a> Unpin for Lookahead1<'a>","synthetic":true,"types":[]},{"text":"impl Unpin for Error","synthetic":true,"types":[]},{"text":"impl<'a> Unpin for ParseBuffer<'a>","synthetic":true,"types":[]},{"text":"impl<'c, 'a> Unpin for StepCursor<'c, 'a>","synthetic":true,"types":[]},{"text":"impl Unpin for Nothing","synthetic":true,"types":[]}]; -implementors["synstructure"] = [{"text":"impl Unpin for AddBounds","synthetic":true,"types":[]},{"text":"impl Unpin for BindStyle","synthetic":true,"types":[]},{"text":"impl<'a> Unpin for BindingInfo<'a>","synthetic":true,"types":[]},{"text":"impl<'a> Unpin for VariantAst<'a>","synthetic":true,"types":[]},{"text":"impl<'a> Unpin for VariantInfo<'a>","synthetic":true,"types":[]},{"text":"impl<'a> Unpin for Structure<'a>","synthetic":true,"types":[]}]; +implementors["delog"] = [{"text":"impl Unpin for U1","synthetic":true,"types":["delog::hex::U1"]},{"text":"impl<'a, T: ?Sized, U, S> Unpin for HexStr<'a, T, U, S> where
    S: Unpin,
    U: Unpin, ","synthetic":true,"types":["delog::hex::HexStr"]},{"text":"impl Unpin for Statistics","synthetic":true,"types":["delog::logger::Statistics"]},{"text":"impl Unpin for DefaultRenderer","synthetic":true,"types":["delog::render::DefaultRenderer"]},{"text":"impl Unpin for RipgrepRenderer","synthetic":true,"types":["delog::render::RipgrepRenderer"]}]; +implementors["flexiber"] = [{"text":"impl<'a> Unpin for Decoder<'a>","synthetic":true,"types":["flexiber::decoder::Decoder"]},{"text":"impl<'a> Unpin for Encoder<'a>","synthetic":true,"types":["flexiber::encoder::Encoder"]},{"text":"impl Unpin for Error","synthetic":true,"types":["flexiber::error::Error"]},{"text":"impl Unpin for ErrorKind","synthetic":true,"types":["flexiber::error::ErrorKind"]},{"text":"impl Unpin for Length","synthetic":true,"types":["flexiber::length::Length"]},{"text":"impl Unpin for SimpleTag","synthetic":true,"types":["flexiber::simpletag::SimpleTag"]},{"text":"impl<'a> Unpin for Slice<'a>","synthetic":true,"types":["flexiber::slice::Slice"]},{"text":"impl Unpin for Class","synthetic":true,"types":["flexiber::tag::Class"]},{"text":"impl Unpin for Tag","synthetic":true,"types":["flexiber::tag::Tag"]},{"text":"impl<V, T> Unpin for TaggedValue<V, T> where
    T: Unpin,
    V: Unpin, ","synthetic":true,"types":["flexiber::tagged::TaggedValue"]}]; +implementors["log"] = [{"text":"impl Unpin for Level","synthetic":true,"types":["log::Level"]},{"text":"impl Unpin for LevelFilter","synthetic":true,"types":["log::LevelFilter"]},{"text":"impl<'a> Unpin for Record<'a>","synthetic":true,"types":["log::Record"]},{"text":"impl<'a> Unpin for RecordBuilder<'a>","synthetic":true,"types":["log::RecordBuilder"]},{"text":"impl<'a> Unpin for Metadata<'a>","synthetic":true,"types":["log::Metadata"]},{"text":"impl<'a> Unpin for MetadataBuilder<'a>","synthetic":true,"types":["log::MetadataBuilder"]},{"text":"impl Unpin for SetLoggerError","synthetic":true,"types":["log::SetLoggerError"]},{"text":"impl Unpin for ParseLevelError","synthetic":true,"types":["log::ParseLevelError"]}]; +implementors["proc_macro2"] = [{"text":"impl Unpin for IntoIter","synthetic":true,"types":["proc_macro2::token_stream::IntoIter"]},{"text":"impl Unpin for TokenStream","synthetic":true,"types":["proc_macro2::TokenStream"]},{"text":"impl Unpin for LexError","synthetic":true,"types":["proc_macro2::LexError"]},{"text":"impl Unpin for Span","synthetic":true,"types":["proc_macro2::Span"]},{"text":"impl Unpin for TokenTree","synthetic":true,"types":["proc_macro2::TokenTree"]},{"text":"impl Unpin for Group","synthetic":true,"types":["proc_macro2::Group"]},{"text":"impl Unpin for Delimiter","synthetic":true,"types":["proc_macro2::Delimiter"]},{"text":"impl Unpin for Punct","synthetic":true,"types":["proc_macro2::Punct"]},{"text":"impl Unpin for Spacing","synthetic":true,"types":["proc_macro2::Spacing"]},{"text":"impl Unpin for Ident","synthetic":true,"types":["proc_macro2::Ident"]},{"text":"impl Unpin for Literal","synthetic":true,"types":["proc_macro2::Literal"]}]; +implementors["syn"] = [{"text":"impl Unpin for Underscore","synthetic":true,"types":["syn::token::Underscore"]},{"text":"impl Unpin for Abstract","synthetic":true,"types":["syn::token::Abstract"]},{"text":"impl Unpin for As","synthetic":true,"types":["syn::token::As"]},{"text":"impl Unpin for Async","synthetic":true,"types":["syn::token::Async"]},{"text":"impl Unpin for Auto","synthetic":true,"types":["syn::token::Auto"]},{"text":"impl Unpin for Await","synthetic":true,"types":["syn::token::Await"]},{"text":"impl Unpin for Become","synthetic":true,"types":["syn::token::Become"]},{"text":"impl Unpin for Box","synthetic":true,"types":["syn::token::Box"]},{"text":"impl Unpin for Break","synthetic":true,"types":["syn::token::Break"]},{"text":"impl Unpin for Const","synthetic":true,"types":["syn::token::Const"]},{"text":"impl Unpin for Continue","synthetic":true,"types":["syn::token::Continue"]},{"text":"impl Unpin for Crate","synthetic":true,"types":["syn::token::Crate"]},{"text":"impl Unpin for Default","synthetic":true,"types":["syn::token::Default"]},{"text":"impl Unpin for Do","synthetic":true,"types":["syn::token::Do"]},{"text":"impl Unpin for Dyn","synthetic":true,"types":["syn::token::Dyn"]},{"text":"impl Unpin for Else","synthetic":true,"types":["syn::token::Else"]},{"text":"impl Unpin for Enum","synthetic":true,"types":["syn::token::Enum"]},{"text":"impl Unpin for Extern","synthetic":true,"types":["syn::token::Extern"]},{"text":"impl Unpin for Final","synthetic":true,"types":["syn::token::Final"]},{"text":"impl Unpin for Fn","synthetic":true,"types":["syn::token::Fn"]},{"text":"impl Unpin for For","synthetic":true,"types":["syn::token::For"]},{"text":"impl Unpin for If","synthetic":true,"types":["syn::token::If"]},{"text":"impl Unpin for Impl","synthetic":true,"types":["syn::token::Impl"]},{"text":"impl Unpin for In","synthetic":true,"types":["syn::token::In"]},{"text":"impl Unpin for Let","synthetic":true,"types":["syn::token::Let"]},{"text":"impl Unpin for Loop","synthetic":true,"types":["syn::token::Loop"]},{"text":"impl Unpin for Macro","synthetic":true,"types":["syn::token::Macro"]},{"text":"impl Unpin for Match","synthetic":true,"types":["syn::token::Match"]},{"text":"impl Unpin for Mod","synthetic":true,"types":["syn::token::Mod"]},{"text":"impl Unpin for Move","synthetic":true,"types":["syn::token::Move"]},{"text":"impl Unpin for Mut","synthetic":true,"types":["syn::token::Mut"]},{"text":"impl Unpin for Override","synthetic":true,"types":["syn::token::Override"]},{"text":"impl Unpin for Priv","synthetic":true,"types":["syn::token::Priv"]},{"text":"impl Unpin for Pub","synthetic":true,"types":["syn::token::Pub"]},{"text":"impl Unpin for Ref","synthetic":true,"types":["syn::token::Ref"]},{"text":"impl Unpin for Return","synthetic":true,"types":["syn::token::Return"]},{"text":"impl Unpin for SelfType","synthetic":true,"types":["syn::token::SelfType"]},{"text":"impl Unpin for SelfValue","synthetic":true,"types":["syn::token::SelfValue"]},{"text":"impl Unpin for Static","synthetic":true,"types":["syn::token::Static"]},{"text":"impl Unpin for Struct","synthetic":true,"types":["syn::token::Struct"]},{"text":"impl Unpin for Super","synthetic":true,"types":["syn::token::Super"]},{"text":"impl Unpin for Trait","synthetic":true,"types":["syn::token::Trait"]},{"text":"impl Unpin for Try","synthetic":true,"types":["syn::token::Try"]},{"text":"impl Unpin for Type","synthetic":true,"types":["syn::token::Type"]},{"text":"impl Unpin for Typeof","synthetic":true,"types":["syn::token::Typeof"]},{"text":"impl Unpin for Union","synthetic":true,"types":["syn::token::Union"]},{"text":"impl Unpin for Unsafe","synthetic":true,"types":["syn::token::Unsafe"]},{"text":"impl Unpin for Unsized","synthetic":true,"types":["syn::token::Unsized"]},{"text":"impl Unpin for Use","synthetic":true,"types":["syn::token::Use"]},{"text":"impl Unpin for Virtual","synthetic":true,"types":["syn::token::Virtual"]},{"text":"impl Unpin for Where","synthetic":true,"types":["syn::token::Where"]},{"text":"impl Unpin for While","synthetic":true,"types":["syn::token::While"]},{"text":"impl Unpin for Yield","synthetic":true,"types":["syn::token::Yield"]},{"text":"impl Unpin for Add","synthetic":true,"types":["syn::token::Add"]},{"text":"impl Unpin for AddEq","synthetic":true,"types":["syn::token::AddEq"]},{"text":"impl Unpin for And","synthetic":true,"types":["syn::token::And"]},{"text":"impl Unpin for AndAnd","synthetic":true,"types":["syn::token::AndAnd"]},{"text":"impl Unpin for AndEq","synthetic":true,"types":["syn::token::AndEq"]},{"text":"impl Unpin for At","synthetic":true,"types":["syn::token::At"]},{"text":"impl Unpin for Bang","synthetic":true,"types":["syn::token::Bang"]},{"text":"impl Unpin for Caret","synthetic":true,"types":["syn::token::Caret"]},{"text":"impl Unpin for CaretEq","synthetic":true,"types":["syn::token::CaretEq"]},{"text":"impl Unpin for Colon","synthetic":true,"types":["syn::token::Colon"]},{"text":"impl Unpin for Colon2","synthetic":true,"types":["syn::token::Colon2"]},{"text":"impl Unpin for Comma","synthetic":true,"types":["syn::token::Comma"]},{"text":"impl Unpin for Div","synthetic":true,"types":["syn::token::Div"]},{"text":"impl Unpin for DivEq","synthetic":true,"types":["syn::token::DivEq"]},{"text":"impl Unpin for Dollar","synthetic":true,"types":["syn::token::Dollar"]},{"text":"impl Unpin for Dot","synthetic":true,"types":["syn::token::Dot"]},{"text":"impl Unpin for Dot2","synthetic":true,"types":["syn::token::Dot2"]},{"text":"impl Unpin for Dot3","synthetic":true,"types":["syn::token::Dot3"]},{"text":"impl Unpin for DotDotEq","synthetic":true,"types":["syn::token::DotDotEq"]},{"text":"impl Unpin for Eq","synthetic":true,"types":["syn::token::Eq"]},{"text":"impl Unpin for EqEq","synthetic":true,"types":["syn::token::EqEq"]},{"text":"impl Unpin for Ge","synthetic":true,"types":["syn::token::Ge"]},{"text":"impl Unpin for Gt","synthetic":true,"types":["syn::token::Gt"]},{"text":"impl Unpin for Le","synthetic":true,"types":["syn::token::Le"]},{"text":"impl Unpin for Lt","synthetic":true,"types":["syn::token::Lt"]},{"text":"impl Unpin for MulEq","synthetic":true,"types":["syn::token::MulEq"]},{"text":"impl Unpin for Ne","synthetic":true,"types":["syn::token::Ne"]},{"text":"impl Unpin for Or","synthetic":true,"types":["syn::token::Or"]},{"text":"impl Unpin for OrEq","synthetic":true,"types":["syn::token::OrEq"]},{"text":"impl Unpin for OrOr","synthetic":true,"types":["syn::token::OrOr"]},{"text":"impl Unpin for Pound","synthetic":true,"types":["syn::token::Pound"]},{"text":"impl Unpin for Question","synthetic":true,"types":["syn::token::Question"]},{"text":"impl Unpin for RArrow","synthetic":true,"types":["syn::token::RArrow"]},{"text":"impl Unpin for LArrow","synthetic":true,"types":["syn::token::LArrow"]},{"text":"impl Unpin for Rem","synthetic":true,"types":["syn::token::Rem"]},{"text":"impl Unpin for RemEq","synthetic":true,"types":["syn::token::RemEq"]},{"text":"impl Unpin for FatArrow","synthetic":true,"types":["syn::token::FatArrow"]},{"text":"impl Unpin for Semi","synthetic":true,"types":["syn::token::Semi"]},{"text":"impl Unpin for Shl","synthetic":true,"types":["syn::token::Shl"]},{"text":"impl Unpin for ShlEq","synthetic":true,"types":["syn::token::ShlEq"]},{"text":"impl Unpin for Shr","synthetic":true,"types":["syn::token::Shr"]},{"text":"impl Unpin for ShrEq","synthetic":true,"types":["syn::token::ShrEq"]},{"text":"impl Unpin for Star","synthetic":true,"types":["syn::token::Star"]},{"text":"impl Unpin for Sub","synthetic":true,"types":["syn::token::Sub"]},{"text":"impl Unpin for SubEq","synthetic":true,"types":["syn::token::SubEq"]},{"text":"impl Unpin for Tilde","synthetic":true,"types":["syn::token::Tilde"]},{"text":"impl Unpin for Brace","synthetic":true,"types":["syn::token::Brace"]},{"text":"impl Unpin for Bracket","synthetic":true,"types":["syn::token::Bracket"]},{"text":"impl Unpin for Paren","synthetic":true,"types":["syn::token::Paren"]},{"text":"impl Unpin for Group","synthetic":true,"types":["syn::token::Group"]},{"text":"impl Unpin for Attribute","synthetic":true,"types":["syn::attr::Attribute"]},{"text":"impl Unpin for AttrStyle","synthetic":true,"types":["syn::attr::AttrStyle"]},{"text":"impl Unpin for Meta","synthetic":true,"types":["syn::attr::Meta"]},{"text":"impl Unpin for MetaList","synthetic":true,"types":["syn::attr::MetaList"]},{"text":"impl Unpin for MetaNameValue","synthetic":true,"types":["syn::attr::MetaNameValue"]},{"text":"impl Unpin for NestedMeta","synthetic":true,"types":["syn::attr::NestedMeta"]},{"text":"impl Unpin for Variant","synthetic":true,"types":["syn::data::Variant"]},{"text":"impl Unpin for Fields","synthetic":true,"types":["syn::data::Fields"]},{"text":"impl Unpin for FieldsNamed","synthetic":true,"types":["syn::data::FieldsNamed"]},{"text":"impl Unpin for FieldsUnnamed","synthetic":true,"types":["syn::data::FieldsUnnamed"]},{"text":"impl Unpin for Field","synthetic":true,"types":["syn::data::Field"]},{"text":"impl Unpin for Visibility","synthetic":true,"types":["syn::data::Visibility"]},{"text":"impl Unpin for VisPublic","synthetic":true,"types":["syn::data::VisPublic"]},{"text":"impl Unpin for VisCrate","synthetic":true,"types":["syn::data::VisCrate"]},{"text":"impl Unpin for VisRestricted","synthetic":true,"types":["syn::data::VisRestricted"]},{"text":"impl Unpin for Expr","synthetic":true,"types":["syn::expr::Expr"]},{"text":"impl Unpin for ExprArray","synthetic":true,"types":["syn::expr::ExprArray"]},{"text":"impl Unpin for ExprAssign","synthetic":true,"types":["syn::expr::ExprAssign"]},{"text":"impl Unpin for ExprAssignOp","synthetic":true,"types":["syn::expr::ExprAssignOp"]},{"text":"impl Unpin for ExprAsync","synthetic":true,"types":["syn::expr::ExprAsync"]},{"text":"impl Unpin for ExprAwait","synthetic":true,"types":["syn::expr::ExprAwait"]},{"text":"impl Unpin for ExprBinary","synthetic":true,"types":["syn::expr::ExprBinary"]},{"text":"impl Unpin for ExprBlock","synthetic":true,"types":["syn::expr::ExprBlock"]},{"text":"impl Unpin for ExprBox","synthetic":true,"types":["syn::expr::ExprBox"]},{"text":"impl Unpin for ExprBreak","synthetic":true,"types":["syn::expr::ExprBreak"]},{"text":"impl Unpin for ExprCall","synthetic":true,"types":["syn::expr::ExprCall"]},{"text":"impl Unpin for ExprCast","synthetic":true,"types":["syn::expr::ExprCast"]},{"text":"impl Unpin for ExprClosure","synthetic":true,"types":["syn::expr::ExprClosure"]},{"text":"impl Unpin for ExprContinue","synthetic":true,"types":["syn::expr::ExprContinue"]},{"text":"impl Unpin for ExprField","synthetic":true,"types":["syn::expr::ExprField"]},{"text":"impl Unpin for ExprForLoop","synthetic":true,"types":["syn::expr::ExprForLoop"]},{"text":"impl Unpin for ExprGroup","synthetic":true,"types":["syn::expr::ExprGroup"]},{"text":"impl Unpin for ExprIf","synthetic":true,"types":["syn::expr::ExprIf"]},{"text":"impl Unpin for ExprIndex","synthetic":true,"types":["syn::expr::ExprIndex"]},{"text":"impl Unpin for ExprLet","synthetic":true,"types":["syn::expr::ExprLet"]},{"text":"impl Unpin for ExprLit","synthetic":true,"types":["syn::expr::ExprLit"]},{"text":"impl Unpin for ExprLoop","synthetic":true,"types":["syn::expr::ExprLoop"]},{"text":"impl Unpin for ExprMacro","synthetic":true,"types":["syn::expr::ExprMacro"]},{"text":"impl Unpin for ExprMatch","synthetic":true,"types":["syn::expr::ExprMatch"]},{"text":"impl Unpin for ExprMethodCall","synthetic":true,"types":["syn::expr::ExprMethodCall"]},{"text":"impl Unpin for ExprParen","synthetic":true,"types":["syn::expr::ExprParen"]},{"text":"impl Unpin for ExprPath","synthetic":true,"types":["syn::expr::ExprPath"]},{"text":"impl Unpin for ExprRange","synthetic":true,"types":["syn::expr::ExprRange"]},{"text":"impl Unpin for ExprReference","synthetic":true,"types":["syn::expr::ExprReference"]},{"text":"impl Unpin for ExprRepeat","synthetic":true,"types":["syn::expr::ExprRepeat"]},{"text":"impl Unpin for ExprReturn","synthetic":true,"types":["syn::expr::ExprReturn"]},{"text":"impl Unpin for ExprStruct","synthetic":true,"types":["syn::expr::ExprStruct"]},{"text":"impl Unpin for ExprTry","synthetic":true,"types":["syn::expr::ExprTry"]},{"text":"impl Unpin for ExprTryBlock","synthetic":true,"types":["syn::expr::ExprTryBlock"]},{"text":"impl Unpin for ExprTuple","synthetic":true,"types":["syn::expr::ExprTuple"]},{"text":"impl Unpin for ExprType","synthetic":true,"types":["syn::expr::ExprType"]},{"text":"impl Unpin for ExprUnary","synthetic":true,"types":["syn::expr::ExprUnary"]},{"text":"impl Unpin for ExprUnsafe","synthetic":true,"types":["syn::expr::ExprUnsafe"]},{"text":"impl Unpin for ExprWhile","synthetic":true,"types":["syn::expr::ExprWhile"]},{"text":"impl Unpin for ExprYield","synthetic":true,"types":["syn::expr::ExprYield"]},{"text":"impl Unpin for Member","synthetic":true,"types":["syn::expr::Member"]},{"text":"impl Unpin for Index","synthetic":true,"types":["syn::expr::Index"]},{"text":"impl Unpin for Generics","synthetic":true,"types":["syn::generics::Generics"]},{"text":"impl Unpin for GenericParam","synthetic":true,"types":["syn::generics::GenericParam"]},{"text":"impl Unpin for TypeParam","synthetic":true,"types":["syn::generics::TypeParam"]},{"text":"impl Unpin for LifetimeDef","synthetic":true,"types":["syn::generics::LifetimeDef"]},{"text":"impl Unpin for ConstParam","synthetic":true,"types":["syn::generics::ConstParam"]},{"text":"impl<'a> Unpin for ImplGenerics<'a>","synthetic":true,"types":["syn::generics::ImplGenerics"]},{"text":"impl<'a> Unpin for TypeGenerics<'a>","synthetic":true,"types":["syn::generics::TypeGenerics"]},{"text":"impl<'a> Unpin for Turbofish<'a>","synthetic":true,"types":["syn::generics::Turbofish"]},{"text":"impl Unpin for BoundLifetimes","synthetic":true,"types":["syn::generics::BoundLifetimes"]},{"text":"impl Unpin for TypeParamBound","synthetic":true,"types":["syn::generics::TypeParamBound"]},{"text":"impl Unpin for TraitBound","synthetic":true,"types":["syn::generics::TraitBound"]},{"text":"impl Unpin for TraitBoundModifier","synthetic":true,"types":["syn::generics::TraitBoundModifier"]},{"text":"impl Unpin for WhereClause","synthetic":true,"types":["syn::generics::WhereClause"]},{"text":"impl Unpin for WherePredicate","synthetic":true,"types":["syn::generics::WherePredicate"]},{"text":"impl Unpin for PredicateType","synthetic":true,"types":["syn::generics::PredicateType"]},{"text":"impl Unpin for PredicateLifetime","synthetic":true,"types":["syn::generics::PredicateLifetime"]},{"text":"impl Unpin for PredicateEq","synthetic":true,"types":["syn::generics::PredicateEq"]},{"text":"impl Unpin for Lifetime","synthetic":true,"types":["syn::lifetime::Lifetime"]},{"text":"impl Unpin for Lit","synthetic":true,"types":["syn::lit::Lit"]},{"text":"impl Unpin for LitStr","synthetic":true,"types":["syn::lit::LitStr"]},{"text":"impl Unpin for LitByteStr","synthetic":true,"types":["syn::lit::LitByteStr"]},{"text":"impl Unpin for LitByte","synthetic":true,"types":["syn::lit::LitByte"]},{"text":"impl Unpin for LitChar","synthetic":true,"types":["syn::lit::LitChar"]},{"text":"impl Unpin for LitInt","synthetic":true,"types":["syn::lit::LitInt"]},{"text":"impl Unpin for LitFloat","synthetic":true,"types":["syn::lit::LitFloat"]},{"text":"impl Unpin for LitBool","synthetic":true,"types":["syn::lit::LitBool"]},{"text":"impl Unpin for StrStyle","synthetic":true,"types":["syn::lit::StrStyle"]},{"text":"impl Unpin for Macro","synthetic":true,"types":["syn::mac::Macro"]},{"text":"impl Unpin for MacroDelimiter","synthetic":true,"types":["syn::mac::MacroDelimiter"]},{"text":"impl Unpin for DeriveInput","synthetic":true,"types":["syn::derive::DeriveInput"]},{"text":"impl Unpin for Data","synthetic":true,"types":["syn::derive::Data"]},{"text":"impl Unpin for DataStruct","synthetic":true,"types":["syn::derive::DataStruct"]},{"text":"impl Unpin for DataEnum","synthetic":true,"types":["syn::derive::DataEnum"]},{"text":"impl Unpin for DataUnion","synthetic":true,"types":["syn::derive::DataUnion"]},{"text":"impl Unpin for BinOp","synthetic":true,"types":["syn::op::BinOp"]},{"text":"impl Unpin for UnOp","synthetic":true,"types":["syn::op::UnOp"]},{"text":"impl Unpin for Type","synthetic":true,"types":["syn::ty::Type"]},{"text":"impl Unpin for TypeArray","synthetic":true,"types":["syn::ty::TypeArray"]},{"text":"impl Unpin for TypeBareFn","synthetic":true,"types":["syn::ty::TypeBareFn"]},{"text":"impl Unpin for TypeGroup","synthetic":true,"types":["syn::ty::TypeGroup"]},{"text":"impl Unpin for TypeImplTrait","synthetic":true,"types":["syn::ty::TypeImplTrait"]},{"text":"impl Unpin for TypeInfer","synthetic":true,"types":["syn::ty::TypeInfer"]},{"text":"impl Unpin for TypeMacro","synthetic":true,"types":["syn::ty::TypeMacro"]},{"text":"impl Unpin for TypeNever","synthetic":true,"types":["syn::ty::TypeNever"]},{"text":"impl Unpin for TypeParen","synthetic":true,"types":["syn::ty::TypeParen"]},{"text":"impl Unpin for TypePath","synthetic":true,"types":["syn::ty::TypePath"]},{"text":"impl Unpin for TypePtr","synthetic":true,"types":["syn::ty::TypePtr"]},{"text":"impl Unpin for TypeReference","synthetic":true,"types":["syn::ty::TypeReference"]},{"text":"impl Unpin for TypeSlice","synthetic":true,"types":["syn::ty::TypeSlice"]},{"text":"impl Unpin for TypeTraitObject","synthetic":true,"types":["syn::ty::TypeTraitObject"]},{"text":"impl Unpin for TypeTuple","synthetic":true,"types":["syn::ty::TypeTuple"]},{"text":"impl Unpin for Abi","synthetic":true,"types":["syn::ty::Abi"]},{"text":"impl Unpin for BareFnArg","synthetic":true,"types":["syn::ty::BareFnArg"]},{"text":"impl Unpin for Variadic","synthetic":true,"types":["syn::ty::Variadic"]},{"text":"impl Unpin for ReturnType","synthetic":true,"types":["syn::ty::ReturnType"]},{"text":"impl Unpin for Path","synthetic":true,"types":["syn::path::Path"]},{"text":"impl Unpin for PathSegment","synthetic":true,"types":["syn::path::PathSegment"]},{"text":"impl Unpin for PathArguments","synthetic":true,"types":["syn::path::PathArguments"]},{"text":"impl Unpin for GenericArgument","synthetic":true,"types":["syn::path::GenericArgument"]},{"text":"impl Unpin for AngleBracketedGenericArguments","synthetic":true,"types":["syn::path::AngleBracketedGenericArguments"]},{"text":"impl Unpin for Binding","synthetic":true,"types":["syn::path::Binding"]},{"text":"impl Unpin for Constraint","synthetic":true,"types":["syn::path::Constraint"]},{"text":"impl Unpin for ParenthesizedGenericArguments","synthetic":true,"types":["syn::path::ParenthesizedGenericArguments"]},{"text":"impl Unpin for QSelf","synthetic":true,"types":["syn::path::QSelf"]},{"text":"impl Unpin for TokenBuffer","synthetic":true,"types":["syn::buffer::TokenBuffer"]},{"text":"impl<'a> Unpin for Cursor<'a>","synthetic":true,"types":["syn::buffer::Cursor"]},{"text":"impl<T, P> Unpin for Punctuated<T, P> where
    P: Unpin,
    T: Unpin, ","synthetic":true,"types":["syn::punctuated::Punctuated"]},{"text":"impl<'a, T, P> Unpin for Pairs<'a, T, P>","synthetic":true,"types":["syn::punctuated::Pairs"]},{"text":"impl<'a, T, P> Unpin for PairsMut<'a, T, P>","synthetic":true,"types":["syn::punctuated::PairsMut"]},{"text":"impl<T, P> Unpin for IntoPairs<T, P> where
    P: Unpin,
    T: Unpin, ","synthetic":true,"types":["syn::punctuated::IntoPairs"]},{"text":"impl<T> Unpin for IntoIter<T> where
    T: Unpin, ","synthetic":true,"types":["syn::punctuated::IntoIter"]},{"text":"impl<'a, T> Unpin for Iter<'a, T>","synthetic":true,"types":["syn::punctuated::Iter"]},{"text":"impl<'a, T> Unpin for IterMut<'a, T>","synthetic":true,"types":["syn::punctuated::IterMut"]},{"text":"impl<T, P> Unpin for Pair<T, P> where
    P: Unpin,
    T: Unpin, ","synthetic":true,"types":["syn::punctuated::Pair"]},{"text":"impl<'a> Unpin for Lookahead1<'a>","synthetic":true,"types":["syn::lookahead::Lookahead1"]},{"text":"impl Unpin for Error","synthetic":true,"types":["syn::error::Error"]},{"text":"impl<'a> Unpin for ParseBuffer<'a>","synthetic":true,"types":["syn::parse::ParseBuffer"]},{"text":"impl<'c, 'a> Unpin for StepCursor<'c, 'a>","synthetic":true,"types":["syn::parse::StepCursor"]},{"text":"impl Unpin for Nothing","synthetic":true,"types":["syn::parse::Nothing"]}]; +implementors["synstructure"] = [{"text":"impl Unpin for AddBounds","synthetic":true,"types":["synstructure::AddBounds"]},{"text":"impl Unpin for BindStyle","synthetic":true,"types":["synstructure::BindStyle"]},{"text":"impl<'a> Unpin for BindingInfo<'a>","synthetic":true,"types":["synstructure::BindingInfo"]},{"text":"impl<'a> Unpin for VariantAst<'a>","synthetic":true,"types":["synstructure::VariantAst"]},{"text":"impl<'a> Unpin for VariantInfo<'a>","synthetic":true,"types":["synstructure::VariantInfo"]},{"text":"impl<'a> Unpin for Structure<'a>","synthetic":true,"types":["synstructure::Structure"]}]; if (window.register_implementors) {window.register_implementors(implementors);} else {window.pending_implementors = implementors;}})() \ No newline at end of file diff --git a/implementors/core/ops/arith/trait.Add.js b/implementors/core/ops/arith/trait.Add.js index c895083..afa3755 100644 --- a/implementors/core/ops/arith/trait.Add.js +++ b/implementors/core/ops/arith/trait.Add.js @@ -1,3 +1,3 @@ (function() {var implementors = {}; -implementors["flexiber"] = [{"text":"impl Add<Length> for Length","synthetic":false,"types":[]},{"text":"impl Add<u8> for Length","synthetic":false,"types":[]},{"text":"impl Add<u16> for Length","synthetic":false,"types":[]},{"text":"impl Add<usize> for Length","synthetic":false,"types":[]},{"text":"impl Add<Length> for Result<Length>","synthetic":false,"types":[]}]; +implementors["flexiber"] = [{"text":"impl Add<Length> for Length","synthetic":false,"types":["flexiber::length::Length"]},{"text":"impl Add<u8> for Length","synthetic":false,"types":["flexiber::length::Length"]},{"text":"impl Add<u16> for Length","synthetic":false,"types":["flexiber::length::Length"]},{"text":"impl Add<usize> for Length","synthetic":false,"types":["flexiber::length::Length"]},{"text":"impl Add<Length> for Result<Length>","synthetic":false,"types":["flexiber::error::Result"]}]; if (window.register_implementors) {window.register_implementors(implementors);} else {window.pending_implementors = implementors;}})() \ No newline at end of file diff --git a/implementors/core/ops/deref/trait.Deref.js b/implementors/core/ops/deref/trait.Deref.js index ce50bf2..bc4a23e 100644 --- a/implementors/core/ops/deref/trait.Deref.js +++ b/implementors/core/ops/deref/trait.Deref.js @@ -1,3 +1,3 @@ (function() {var implementors = {}; -implementors["syn"] = [{"text":"impl Deref for Underscore","synthetic":false,"types":[]},{"text":"impl Deref for Add","synthetic":false,"types":[]},{"text":"impl Deref for And","synthetic":false,"types":[]},{"text":"impl Deref for At","synthetic":false,"types":[]},{"text":"impl Deref for Bang","synthetic":false,"types":[]},{"text":"impl Deref for Caret","synthetic":false,"types":[]},{"text":"impl Deref for Colon","synthetic":false,"types":[]},{"text":"impl Deref for Comma","synthetic":false,"types":[]},{"text":"impl Deref for Div","synthetic":false,"types":[]},{"text":"impl Deref for Dollar","synthetic":false,"types":[]},{"text":"impl Deref for Dot","synthetic":false,"types":[]},{"text":"impl Deref for Eq","synthetic":false,"types":[]},{"text":"impl Deref for Gt","synthetic":false,"types":[]},{"text":"impl Deref for Lt","synthetic":false,"types":[]},{"text":"impl Deref for Or","synthetic":false,"types":[]},{"text":"impl Deref for Pound","synthetic":false,"types":[]},{"text":"impl Deref for Question","synthetic":false,"types":[]},{"text":"impl Deref for Rem","synthetic":false,"types":[]},{"text":"impl Deref for Semi","synthetic":false,"types":[]},{"text":"impl Deref for Star","synthetic":false,"types":[]},{"text":"impl Deref for Sub","synthetic":false,"types":[]},{"text":"impl Deref for Tilde","synthetic":false,"types":[]},{"text":"impl<'c, 'a> Deref for StepCursor<'c, 'a>","synthetic":false,"types":[]}]; +implementors["syn"] = [{"text":"impl Deref for Underscore","synthetic":false,"types":["syn::token::Underscore"]},{"text":"impl Deref for Add","synthetic":false,"types":["syn::token::Add"]},{"text":"impl Deref for And","synthetic":false,"types":["syn::token::And"]},{"text":"impl Deref for At","synthetic":false,"types":["syn::token::At"]},{"text":"impl Deref for Bang","synthetic":false,"types":["syn::token::Bang"]},{"text":"impl Deref for Caret","synthetic":false,"types":["syn::token::Caret"]},{"text":"impl Deref for Colon","synthetic":false,"types":["syn::token::Colon"]},{"text":"impl Deref for Comma","synthetic":false,"types":["syn::token::Comma"]},{"text":"impl Deref for Div","synthetic":false,"types":["syn::token::Div"]},{"text":"impl Deref for Dollar","synthetic":false,"types":["syn::token::Dollar"]},{"text":"impl Deref for Dot","synthetic":false,"types":["syn::token::Dot"]},{"text":"impl Deref for Eq","synthetic":false,"types":["syn::token::Eq"]},{"text":"impl Deref for Gt","synthetic":false,"types":["syn::token::Gt"]},{"text":"impl Deref for Lt","synthetic":false,"types":["syn::token::Lt"]},{"text":"impl Deref for Or","synthetic":false,"types":["syn::token::Or"]},{"text":"impl Deref for Pound","synthetic":false,"types":["syn::token::Pound"]},{"text":"impl Deref for Question","synthetic":false,"types":["syn::token::Question"]},{"text":"impl Deref for Rem","synthetic":false,"types":["syn::token::Rem"]},{"text":"impl Deref for Semi","synthetic":false,"types":["syn::token::Semi"]},{"text":"impl Deref for Star","synthetic":false,"types":["syn::token::Star"]},{"text":"impl Deref for Sub","synthetic":false,"types":["syn::token::Sub"]},{"text":"impl Deref for Tilde","synthetic":false,"types":["syn::token::Tilde"]},{"text":"impl<'c, 'a> Deref for StepCursor<'c, 'a>","synthetic":false,"types":["syn::parse::StepCursor"]}]; if (window.register_implementors) {window.register_implementors(implementors);} else {window.pending_implementors = implementors;}})() \ No newline at end of file diff --git a/implementors/core/ops/deref/trait.DerefMut.js b/implementors/core/ops/deref/trait.DerefMut.js index 7b0d012..73d1a9d 100644 --- a/implementors/core/ops/deref/trait.DerefMut.js +++ b/implementors/core/ops/deref/trait.DerefMut.js @@ -1,3 +1,3 @@ (function() {var implementors = {}; -implementors["syn"] = [{"text":"impl DerefMut for Underscore","synthetic":false,"types":[]},{"text":"impl DerefMut for Add","synthetic":false,"types":[]},{"text":"impl DerefMut for And","synthetic":false,"types":[]},{"text":"impl DerefMut for At","synthetic":false,"types":[]},{"text":"impl DerefMut for Bang","synthetic":false,"types":[]},{"text":"impl DerefMut for Caret","synthetic":false,"types":[]},{"text":"impl DerefMut for Colon","synthetic":false,"types":[]},{"text":"impl DerefMut for Comma","synthetic":false,"types":[]},{"text":"impl DerefMut for Div","synthetic":false,"types":[]},{"text":"impl DerefMut for Dollar","synthetic":false,"types":[]},{"text":"impl DerefMut for Dot","synthetic":false,"types":[]},{"text":"impl DerefMut for Eq","synthetic":false,"types":[]},{"text":"impl DerefMut for Gt","synthetic":false,"types":[]},{"text":"impl DerefMut for Lt","synthetic":false,"types":[]},{"text":"impl DerefMut for Or","synthetic":false,"types":[]},{"text":"impl DerefMut for Pound","synthetic":false,"types":[]},{"text":"impl DerefMut for Question","synthetic":false,"types":[]},{"text":"impl DerefMut for Rem","synthetic":false,"types":[]},{"text":"impl DerefMut for Semi","synthetic":false,"types":[]},{"text":"impl DerefMut for Star","synthetic":false,"types":[]},{"text":"impl DerefMut for Sub","synthetic":false,"types":[]},{"text":"impl DerefMut for Tilde","synthetic":false,"types":[]}]; +implementors["syn"] = [{"text":"impl DerefMut for Underscore","synthetic":false,"types":["syn::token::Underscore"]},{"text":"impl DerefMut for Add","synthetic":false,"types":["syn::token::Add"]},{"text":"impl DerefMut for And","synthetic":false,"types":["syn::token::And"]},{"text":"impl DerefMut for At","synthetic":false,"types":["syn::token::At"]},{"text":"impl DerefMut for Bang","synthetic":false,"types":["syn::token::Bang"]},{"text":"impl DerefMut for Caret","synthetic":false,"types":["syn::token::Caret"]},{"text":"impl DerefMut for Colon","synthetic":false,"types":["syn::token::Colon"]},{"text":"impl DerefMut for Comma","synthetic":false,"types":["syn::token::Comma"]},{"text":"impl DerefMut for Div","synthetic":false,"types":["syn::token::Div"]},{"text":"impl DerefMut for Dollar","synthetic":false,"types":["syn::token::Dollar"]},{"text":"impl DerefMut for Dot","synthetic":false,"types":["syn::token::Dot"]},{"text":"impl DerefMut for Eq","synthetic":false,"types":["syn::token::Eq"]},{"text":"impl DerefMut for Gt","synthetic":false,"types":["syn::token::Gt"]},{"text":"impl DerefMut for Lt","synthetic":false,"types":["syn::token::Lt"]},{"text":"impl DerefMut for Or","synthetic":false,"types":["syn::token::Or"]},{"text":"impl DerefMut for Pound","synthetic":false,"types":["syn::token::Pound"]},{"text":"impl DerefMut for Question","synthetic":false,"types":["syn::token::Question"]},{"text":"impl DerefMut for Rem","synthetic":false,"types":["syn::token::Rem"]},{"text":"impl DerefMut for Semi","synthetic":false,"types":["syn::token::Semi"]},{"text":"impl DerefMut for Star","synthetic":false,"types":["syn::token::Star"]},{"text":"impl DerefMut for Sub","synthetic":false,"types":["syn::token::Sub"]},{"text":"impl DerefMut for Tilde","synthetic":false,"types":["syn::token::Tilde"]}]; if (window.register_implementors) {window.register_implementors(implementors);} else {window.pending_implementors = implementors;}})() \ No newline at end of file diff --git a/implementors/core/ops/drop/trait.Drop.js b/implementors/core/ops/drop/trait.Drop.js index a05d1fd..c0016b6 100644 --- a/implementors/core/ops/drop/trait.Drop.js +++ b/implementors/core/ops/drop/trait.Drop.js @@ -1,3 +1,3 @@ (function() {var implementors = {}; -implementors["syn"] = [{"text":"impl<'a> Drop for ParseBuffer<'a>","synthetic":false,"types":[]}]; +implementors["syn"] = [{"text":"impl<'a> Drop for ParseBuffer<'a>","synthetic":false,"types":["syn::parse::ParseBuffer"]}]; if (window.register_implementors) {window.register_implementors(implementors);} else {window.pending_implementors = implementors;}})() \ No newline at end of file diff --git a/implementors/core/ops/index/trait.Index.js b/implementors/core/ops/index/trait.Index.js index 7d2bfaf..53a6664 100644 --- a/implementors/core/ops/index/trait.Index.js +++ b/implementors/core/ops/index/trait.Index.js @@ -1,3 +1,3 @@ (function() {var implementors = {}; -implementors["syn"] = [{"text":"impl<T, P> Index<usize> for Punctuated<T, P>","synthetic":false,"types":[]}]; +implementors["syn"] = [{"text":"impl<T, P> Index<usize> for Punctuated<T, P>","synthetic":false,"types":["syn::punctuated::Punctuated"]}]; if (window.register_implementors) {window.register_implementors(implementors);} else {window.pending_implementors = implementors;}})() \ No newline at end of file diff --git a/implementors/core/ops/index/trait.IndexMut.js b/implementors/core/ops/index/trait.IndexMut.js index 816681f..135bb27 100644 --- a/implementors/core/ops/index/trait.IndexMut.js +++ b/implementors/core/ops/index/trait.IndexMut.js @@ -1,3 +1,3 @@ (function() {var implementors = {}; -implementors["syn"] = [{"text":"impl<T, P> IndexMut<usize> for Punctuated<T, P>","synthetic":false,"types":[]}]; +implementors["syn"] = [{"text":"impl<T, P> IndexMut<usize> for Punctuated<T, P>","synthetic":false,"types":["syn::punctuated::Punctuated"]}]; if (window.register_implementors) {window.register_implementors(implementors);} else {window.pending_implementors = implementors;}})() \ No newline at end of file diff --git a/implementors/core/str/traits/trait.FromStr.js b/implementors/core/str/traits/trait.FromStr.js index 59d1deb..fbee8c5 100644 --- a/implementors/core/str/traits/trait.FromStr.js +++ b/implementors/core/str/traits/trait.FromStr.js @@ -1,4 +1,4 @@ (function() {var implementors = {}; -implementors["log"] = [{"text":"impl FromStr for Level","synthetic":false,"types":[]},{"text":"impl FromStr for LevelFilter","synthetic":false,"types":[]}]; -implementors["proc_macro2"] = [{"text":"impl FromStr for TokenStream","synthetic":false,"types":[]}]; +implementors["log"] = [{"text":"impl FromStr for Level","synthetic":false,"types":["log::Level"]},{"text":"impl FromStr for LevelFilter","synthetic":false,"types":["log::LevelFilter"]}]; +implementors["proc_macro2"] = [{"text":"impl FromStr for TokenStream","synthetic":false,"types":["proc_macro2::TokenStream"]},{"text":"impl FromStr for Literal","synthetic":false,"types":["proc_macro2::Literal"]}]; if (window.register_implementors) {window.register_implementors(implementors);} else {window.pending_implementors = implementors;}})() \ No newline at end of file diff --git a/implementors/quote/ident_fragment/trait.IdentFragment.js b/implementors/quote/ident_fragment/trait.IdentFragment.js index 497e355..5335ee6 100644 --- a/implementors/quote/ident_fragment/trait.IdentFragment.js +++ b/implementors/quote/ident_fragment/trait.IdentFragment.js @@ -1,3 +1,3 @@ (function() {var implementors = {}; -implementors["syn"] = [{"text":"impl IdentFragment for Member","synthetic":false,"types":[]},{"text":"impl IdentFragment for Index","synthetic":false,"types":[]}]; +implementors["syn"] = [{"text":"impl IdentFragment for Member","synthetic":false,"types":["syn::expr::Member"]},{"text":"impl IdentFragment for Index","synthetic":false,"types":["syn::expr::Index"]}]; if (window.register_implementors) {window.register_implementors(implementors);} else {window.pending_implementors = implementors;}})() \ No newline at end of file diff --git a/implementors/quote/to_tokens/trait.ToTokens.js b/implementors/quote/to_tokens/trait.ToTokens.js index 4e60901..2f6d7b2 100644 --- a/implementors/quote/to_tokens/trait.ToTokens.js +++ b/implementors/quote/to_tokens/trait.ToTokens.js @@ -1,4 +1,4 @@ (function() {var implementors = {}; -implementors["syn"] = [{"text":"impl ToTokens for Underscore","synthetic":false,"types":[]},{"text":"impl ToTokens for Abstract","synthetic":false,"types":[]},{"text":"impl ToTokens for As","synthetic":false,"types":[]},{"text":"impl ToTokens for Async","synthetic":false,"types":[]},{"text":"impl ToTokens for Auto","synthetic":false,"types":[]},{"text":"impl ToTokens for Await","synthetic":false,"types":[]},{"text":"impl ToTokens for Become","synthetic":false,"types":[]},{"text":"impl ToTokens for Box","synthetic":false,"types":[]},{"text":"impl ToTokens for Break","synthetic":false,"types":[]},{"text":"impl ToTokens for Const","synthetic":false,"types":[]},{"text":"impl ToTokens for Continue","synthetic":false,"types":[]},{"text":"impl ToTokens for Crate","synthetic":false,"types":[]},{"text":"impl ToTokens for Default","synthetic":false,"types":[]},{"text":"impl ToTokens for Do","synthetic":false,"types":[]},{"text":"impl ToTokens for Dyn","synthetic":false,"types":[]},{"text":"impl ToTokens for Else","synthetic":false,"types":[]},{"text":"impl ToTokens for Enum","synthetic":false,"types":[]},{"text":"impl ToTokens for Extern","synthetic":false,"types":[]},{"text":"impl ToTokens for Final","synthetic":false,"types":[]},{"text":"impl ToTokens for Fn","synthetic":false,"types":[]},{"text":"impl ToTokens for For","synthetic":false,"types":[]},{"text":"impl ToTokens for If","synthetic":false,"types":[]},{"text":"impl ToTokens for Impl","synthetic":false,"types":[]},{"text":"impl ToTokens for In","synthetic":false,"types":[]},{"text":"impl ToTokens for Let","synthetic":false,"types":[]},{"text":"impl ToTokens for Loop","synthetic":false,"types":[]},{"text":"impl ToTokens for Macro","synthetic":false,"types":[]},{"text":"impl ToTokens for Match","synthetic":false,"types":[]},{"text":"impl ToTokens for Mod","synthetic":false,"types":[]},{"text":"impl ToTokens for Move","synthetic":false,"types":[]},{"text":"impl ToTokens for Mut","synthetic":false,"types":[]},{"text":"impl ToTokens for Override","synthetic":false,"types":[]},{"text":"impl ToTokens for Priv","synthetic":false,"types":[]},{"text":"impl ToTokens for Pub","synthetic":false,"types":[]},{"text":"impl ToTokens for Ref","synthetic":false,"types":[]},{"text":"impl ToTokens for Return","synthetic":false,"types":[]},{"text":"impl ToTokens for SelfType","synthetic":false,"types":[]},{"text":"impl ToTokens for SelfValue","synthetic":false,"types":[]},{"text":"impl ToTokens for Static","synthetic":false,"types":[]},{"text":"impl ToTokens for Struct","synthetic":false,"types":[]},{"text":"impl ToTokens for Super","synthetic":false,"types":[]},{"text":"impl ToTokens for Trait","synthetic":false,"types":[]},{"text":"impl ToTokens for Try","synthetic":false,"types":[]},{"text":"impl ToTokens for Type","synthetic":false,"types":[]},{"text":"impl ToTokens for Typeof","synthetic":false,"types":[]},{"text":"impl ToTokens for Union","synthetic":false,"types":[]},{"text":"impl ToTokens for Unsafe","synthetic":false,"types":[]},{"text":"impl ToTokens for Unsized","synthetic":false,"types":[]},{"text":"impl ToTokens for Use","synthetic":false,"types":[]},{"text":"impl ToTokens for Virtual","synthetic":false,"types":[]},{"text":"impl ToTokens for Where","synthetic":false,"types":[]},{"text":"impl ToTokens for While","synthetic":false,"types":[]},{"text":"impl ToTokens for Yield","synthetic":false,"types":[]},{"text":"impl ToTokens for Add","synthetic":false,"types":[]},{"text":"impl ToTokens for AddEq","synthetic":false,"types":[]},{"text":"impl ToTokens for And","synthetic":false,"types":[]},{"text":"impl ToTokens for AndAnd","synthetic":false,"types":[]},{"text":"impl ToTokens for AndEq","synthetic":false,"types":[]},{"text":"impl ToTokens for At","synthetic":false,"types":[]},{"text":"impl ToTokens for Bang","synthetic":false,"types":[]},{"text":"impl ToTokens for Caret","synthetic":false,"types":[]},{"text":"impl ToTokens for CaretEq","synthetic":false,"types":[]},{"text":"impl ToTokens for Colon","synthetic":false,"types":[]},{"text":"impl ToTokens for Colon2","synthetic":false,"types":[]},{"text":"impl ToTokens for Comma","synthetic":false,"types":[]},{"text":"impl ToTokens for Div","synthetic":false,"types":[]},{"text":"impl ToTokens for DivEq","synthetic":false,"types":[]},{"text":"impl ToTokens for Dollar","synthetic":false,"types":[]},{"text":"impl ToTokens for Dot","synthetic":false,"types":[]},{"text":"impl ToTokens for Dot2","synthetic":false,"types":[]},{"text":"impl ToTokens for Dot3","synthetic":false,"types":[]},{"text":"impl ToTokens for DotDotEq","synthetic":false,"types":[]},{"text":"impl ToTokens for Eq","synthetic":false,"types":[]},{"text":"impl ToTokens for EqEq","synthetic":false,"types":[]},{"text":"impl ToTokens for Ge","synthetic":false,"types":[]},{"text":"impl ToTokens for Gt","synthetic":false,"types":[]},{"text":"impl ToTokens for Le","synthetic":false,"types":[]},{"text":"impl ToTokens for Lt","synthetic":false,"types":[]},{"text":"impl ToTokens for MulEq","synthetic":false,"types":[]},{"text":"impl ToTokens for Ne","synthetic":false,"types":[]},{"text":"impl ToTokens for Or","synthetic":false,"types":[]},{"text":"impl ToTokens for OrEq","synthetic":false,"types":[]},{"text":"impl ToTokens for OrOr","synthetic":false,"types":[]},{"text":"impl ToTokens for Pound","synthetic":false,"types":[]},{"text":"impl ToTokens for Question","synthetic":false,"types":[]},{"text":"impl ToTokens for RArrow","synthetic":false,"types":[]},{"text":"impl ToTokens for LArrow","synthetic":false,"types":[]},{"text":"impl ToTokens for Rem","synthetic":false,"types":[]},{"text":"impl ToTokens for RemEq","synthetic":false,"types":[]},{"text":"impl ToTokens for FatArrow","synthetic":false,"types":[]},{"text":"impl ToTokens for Semi","synthetic":false,"types":[]},{"text":"impl ToTokens for Shl","synthetic":false,"types":[]},{"text":"impl ToTokens for ShlEq","synthetic":false,"types":[]},{"text":"impl ToTokens for Shr","synthetic":false,"types":[]},{"text":"impl ToTokens for ShrEq","synthetic":false,"types":[]},{"text":"impl ToTokens for Star","synthetic":false,"types":[]},{"text":"impl ToTokens for Sub","synthetic":false,"types":[]},{"text":"impl ToTokens for SubEq","synthetic":false,"types":[]},{"text":"impl ToTokens for Tilde","synthetic":false,"types":[]},{"text":"impl ToTokens for Meta","synthetic":false,"types":[]},{"text":"impl ToTokens for NestedMeta","synthetic":false,"types":[]},{"text":"impl ToTokens for Attribute","synthetic":false,"types":[]},{"text":"impl ToTokens for MetaList","synthetic":false,"types":[]},{"text":"impl ToTokens for MetaNameValue","synthetic":false,"types":[]},{"text":"impl ToTokens for Fields","synthetic":false,"types":[]},{"text":"impl ToTokens for Visibility","synthetic":false,"types":[]},{"text":"impl ToTokens for Variant","synthetic":false,"types":[]},{"text":"impl ToTokens for FieldsNamed","synthetic":false,"types":[]},{"text":"impl ToTokens for FieldsUnnamed","synthetic":false,"types":[]},{"text":"impl ToTokens for Field","synthetic":false,"types":[]},{"text":"impl ToTokens for VisPublic","synthetic":false,"types":[]},{"text":"impl ToTokens for VisCrate","synthetic":false,"types":[]},{"text":"impl ToTokens for VisRestricted","synthetic":false,"types":[]},{"text":"impl ToTokens for Expr","synthetic":false,"types":[]},{"text":"impl ToTokens for ExprArray","synthetic":false,"types":[]},{"text":"impl ToTokens for ExprAssign","synthetic":false,"types":[]},{"text":"impl ToTokens for ExprAssignOp","synthetic":false,"types":[]},{"text":"impl ToTokens for ExprAsync","synthetic":false,"types":[]},{"text":"impl ToTokens for ExprAwait","synthetic":false,"types":[]},{"text":"impl ToTokens for ExprBlock","synthetic":false,"types":[]},{"text":"impl ToTokens for ExprBox","synthetic":false,"types":[]},{"text":"impl ToTokens for ExprBreak","synthetic":false,"types":[]},{"text":"impl ToTokens for ExprClosure","synthetic":false,"types":[]},{"text":"impl ToTokens for ExprContinue","synthetic":false,"types":[]},{"text":"impl ToTokens for ExprForLoop","synthetic":false,"types":[]},{"text":"impl ToTokens for ExprGroup","synthetic":false,"types":[]},{"text":"impl ToTokens for ExprIf","synthetic":false,"types":[]},{"text":"impl ToTokens for ExprLet","synthetic":false,"types":[]},{"text":"impl ToTokens for ExprLoop","synthetic":false,"types":[]},{"text":"impl ToTokens for ExprMacro","synthetic":false,"types":[]},{"text":"impl ToTokens for ExprMatch","synthetic":false,"types":[]},{"text":"impl ToTokens for ExprMethodCall","synthetic":false,"types":[]},{"text":"impl ToTokens for ExprRange","synthetic":false,"types":[]},{"text":"impl ToTokens for ExprReference","synthetic":false,"types":[]},{"text":"impl ToTokens for ExprRepeat","synthetic":false,"types":[]},{"text":"impl ToTokens for ExprReturn","synthetic":false,"types":[]},{"text":"impl ToTokens for ExprStruct","synthetic":false,"types":[]},{"text":"impl ToTokens for ExprTry","synthetic":false,"types":[]},{"text":"impl ToTokens for ExprTryBlock","synthetic":false,"types":[]},{"text":"impl ToTokens for ExprTuple","synthetic":false,"types":[]},{"text":"impl ToTokens for ExprType","synthetic":false,"types":[]},{"text":"impl ToTokens for ExprUnsafe","synthetic":false,"types":[]},{"text":"impl ToTokens for ExprWhile","synthetic":false,"types":[]},{"text":"impl ToTokens for ExprYield","synthetic":false,"types":[]},{"text":"impl ToTokens for ExprCall","synthetic":false,"types":[]},{"text":"impl ToTokens for ExprBinary","synthetic":false,"types":[]},{"text":"impl ToTokens for ExprUnary","synthetic":false,"types":[]},{"text":"impl ToTokens for ExprLit","synthetic":false,"types":[]},{"text":"impl ToTokens for ExprCast","synthetic":false,"types":[]},{"text":"impl ToTokens for ExprField","synthetic":false,"types":[]},{"text":"impl ToTokens for Member","synthetic":false,"types":[]},{"text":"impl ToTokens for Index","synthetic":false,"types":[]},{"text":"impl ToTokens for ExprIndex","synthetic":false,"types":[]},{"text":"impl ToTokens for ExprPath","synthetic":false,"types":[]},{"text":"impl ToTokens for ExprParen","synthetic":false,"types":[]},{"text":"impl ToTokens for GenericParam","synthetic":false,"types":[]},{"text":"impl ToTokens for TypeParamBound","synthetic":false,"types":[]},{"text":"impl ToTokens for WherePredicate","synthetic":false,"types":[]},{"text":"impl ToTokens for Generics","synthetic":false,"types":[]},{"text":"impl<'a> ToTokens for ImplGenerics<'a>","synthetic":false,"types":[]},{"text":"impl<'a> ToTokens for TypeGenerics<'a>","synthetic":false,"types":[]},{"text":"impl<'a> ToTokens for Turbofish<'a>","synthetic":false,"types":[]},{"text":"impl ToTokens for BoundLifetimes","synthetic":false,"types":[]},{"text":"impl ToTokens for LifetimeDef","synthetic":false,"types":[]},{"text":"impl ToTokens for TypeParam","synthetic":false,"types":[]},{"text":"impl ToTokens for TraitBound","synthetic":false,"types":[]},{"text":"impl ToTokens for TraitBoundModifier","synthetic":false,"types":[]},{"text":"impl ToTokens for ConstParam","synthetic":false,"types":[]},{"text":"impl ToTokens for WhereClause","synthetic":false,"types":[]},{"text":"impl ToTokens for PredicateType","synthetic":false,"types":[]},{"text":"impl ToTokens for PredicateLifetime","synthetic":false,"types":[]},{"text":"impl ToTokens for PredicateEq","synthetic":false,"types":[]},{"text":"impl ToTokens for Lifetime","synthetic":false,"types":[]},{"text":"impl ToTokens for Lit","synthetic":false,"types":[]},{"text":"impl ToTokens for LitStr","synthetic":false,"types":[]},{"text":"impl ToTokens for LitByteStr","synthetic":false,"types":[]},{"text":"impl ToTokens for LitByte","synthetic":false,"types":[]},{"text":"impl ToTokens for LitChar","synthetic":false,"types":[]},{"text":"impl ToTokens for LitInt","synthetic":false,"types":[]},{"text":"impl ToTokens for LitFloat","synthetic":false,"types":[]},{"text":"impl ToTokens for LitBool","synthetic":false,"types":[]},{"text":"impl ToTokens for Macro","synthetic":false,"types":[]},{"text":"impl ToTokens for DeriveInput","synthetic":false,"types":[]},{"text":"impl ToTokens for BinOp","synthetic":false,"types":[]},{"text":"impl ToTokens for UnOp","synthetic":false,"types":[]},{"text":"impl ToTokens for Type","synthetic":false,"types":[]},{"text":"impl ToTokens for TypeSlice","synthetic":false,"types":[]},{"text":"impl ToTokens for TypeArray","synthetic":false,"types":[]},{"text":"impl ToTokens for TypePtr","synthetic":false,"types":[]},{"text":"impl ToTokens for TypeReference","synthetic":false,"types":[]},{"text":"impl ToTokens for TypeBareFn","synthetic":false,"types":[]},{"text":"impl ToTokens for TypeNever","synthetic":false,"types":[]},{"text":"impl ToTokens for TypeTuple","synthetic":false,"types":[]},{"text":"impl ToTokens for TypePath","synthetic":false,"types":[]},{"text":"impl ToTokens for TypeTraitObject","synthetic":false,"types":[]},{"text":"impl ToTokens for TypeImplTrait","synthetic":false,"types":[]},{"text":"impl ToTokens for TypeGroup","synthetic":false,"types":[]},{"text":"impl ToTokens for TypeParen","synthetic":false,"types":[]},{"text":"impl ToTokens for TypeInfer","synthetic":false,"types":[]},{"text":"impl ToTokens for TypeMacro","synthetic":false,"types":[]},{"text":"impl ToTokens for ReturnType","synthetic":false,"types":[]},{"text":"impl ToTokens for BareFnArg","synthetic":false,"types":[]},{"text":"impl ToTokens for Variadic","synthetic":false,"types":[]},{"text":"impl ToTokens for Abi","synthetic":false,"types":[]},{"text":"impl ToTokens for Path","synthetic":false,"types":[]},{"text":"impl ToTokens for PathSegment","synthetic":false,"types":[]},{"text":"impl ToTokens for PathArguments","synthetic":false,"types":[]},{"text":"impl ToTokens for GenericArgument","synthetic":false,"types":[]},{"text":"impl ToTokens for AngleBracketedGenericArguments","synthetic":false,"types":[]},{"text":"impl ToTokens for Binding","synthetic":false,"types":[]},{"text":"impl ToTokens for Constraint","synthetic":false,"types":[]},{"text":"impl ToTokens for ParenthesizedGenericArguments","synthetic":false,"types":[]},{"text":"impl<T, P> ToTokens for Punctuated<T, P> where
    T: ToTokens,
    P: ToTokens, ","synthetic":false,"types":[]},{"text":"impl<T, P> ToTokens for Pair<T, P> where
    T: ToTokens,
    P: ToTokens, ","synthetic":false,"types":[]}]; -implementors["synstructure"] = [{"text":"impl ToTokens for BindStyle","synthetic":false,"types":[]},{"text":"impl<'a> ToTokens for BindingInfo<'a>","synthetic":false,"types":[]}]; +implementors["syn"] = [{"text":"impl ToTokens for Underscore","synthetic":false,"types":["syn::token::Underscore"]},{"text":"impl ToTokens for Abstract","synthetic":false,"types":["syn::token::Abstract"]},{"text":"impl ToTokens for As","synthetic":false,"types":["syn::token::As"]},{"text":"impl ToTokens for Async","synthetic":false,"types":["syn::token::Async"]},{"text":"impl ToTokens for Auto","synthetic":false,"types":["syn::token::Auto"]},{"text":"impl ToTokens for Await","synthetic":false,"types":["syn::token::Await"]},{"text":"impl ToTokens for Become","synthetic":false,"types":["syn::token::Become"]},{"text":"impl ToTokens for Box","synthetic":false,"types":["syn::token::Box"]},{"text":"impl ToTokens for Break","synthetic":false,"types":["syn::token::Break"]},{"text":"impl ToTokens for Const","synthetic":false,"types":["syn::token::Const"]},{"text":"impl ToTokens for Continue","synthetic":false,"types":["syn::token::Continue"]},{"text":"impl ToTokens for Crate","synthetic":false,"types":["syn::token::Crate"]},{"text":"impl ToTokens for Default","synthetic":false,"types":["syn::token::Default"]},{"text":"impl ToTokens for Do","synthetic":false,"types":["syn::token::Do"]},{"text":"impl ToTokens for Dyn","synthetic":false,"types":["syn::token::Dyn"]},{"text":"impl ToTokens for Else","synthetic":false,"types":["syn::token::Else"]},{"text":"impl ToTokens for Enum","synthetic":false,"types":["syn::token::Enum"]},{"text":"impl ToTokens for Extern","synthetic":false,"types":["syn::token::Extern"]},{"text":"impl ToTokens for Final","synthetic":false,"types":["syn::token::Final"]},{"text":"impl ToTokens for Fn","synthetic":false,"types":["syn::token::Fn"]},{"text":"impl ToTokens for For","synthetic":false,"types":["syn::token::For"]},{"text":"impl ToTokens for If","synthetic":false,"types":["syn::token::If"]},{"text":"impl ToTokens for Impl","synthetic":false,"types":["syn::token::Impl"]},{"text":"impl ToTokens for In","synthetic":false,"types":["syn::token::In"]},{"text":"impl ToTokens for Let","synthetic":false,"types":["syn::token::Let"]},{"text":"impl ToTokens for Loop","synthetic":false,"types":["syn::token::Loop"]},{"text":"impl ToTokens for Macro","synthetic":false,"types":["syn::token::Macro"]},{"text":"impl ToTokens for Match","synthetic":false,"types":["syn::token::Match"]},{"text":"impl ToTokens for Mod","synthetic":false,"types":["syn::token::Mod"]},{"text":"impl ToTokens for Move","synthetic":false,"types":["syn::token::Move"]},{"text":"impl ToTokens for Mut","synthetic":false,"types":["syn::token::Mut"]},{"text":"impl ToTokens for Override","synthetic":false,"types":["syn::token::Override"]},{"text":"impl ToTokens for Priv","synthetic":false,"types":["syn::token::Priv"]},{"text":"impl ToTokens for Pub","synthetic":false,"types":["syn::token::Pub"]},{"text":"impl ToTokens for Ref","synthetic":false,"types":["syn::token::Ref"]},{"text":"impl ToTokens for Return","synthetic":false,"types":["syn::token::Return"]},{"text":"impl ToTokens for SelfType","synthetic":false,"types":["syn::token::SelfType"]},{"text":"impl ToTokens for SelfValue","synthetic":false,"types":["syn::token::SelfValue"]},{"text":"impl ToTokens for Static","synthetic":false,"types":["syn::token::Static"]},{"text":"impl ToTokens for Struct","synthetic":false,"types":["syn::token::Struct"]},{"text":"impl ToTokens for Super","synthetic":false,"types":["syn::token::Super"]},{"text":"impl ToTokens for Trait","synthetic":false,"types":["syn::token::Trait"]},{"text":"impl ToTokens for Try","synthetic":false,"types":["syn::token::Try"]},{"text":"impl ToTokens for Type","synthetic":false,"types":["syn::token::Type"]},{"text":"impl ToTokens for Typeof","synthetic":false,"types":["syn::token::Typeof"]},{"text":"impl ToTokens for Union","synthetic":false,"types":["syn::token::Union"]},{"text":"impl ToTokens for Unsafe","synthetic":false,"types":["syn::token::Unsafe"]},{"text":"impl ToTokens for Unsized","synthetic":false,"types":["syn::token::Unsized"]},{"text":"impl ToTokens for Use","synthetic":false,"types":["syn::token::Use"]},{"text":"impl ToTokens for Virtual","synthetic":false,"types":["syn::token::Virtual"]},{"text":"impl ToTokens for Where","synthetic":false,"types":["syn::token::Where"]},{"text":"impl ToTokens for While","synthetic":false,"types":["syn::token::While"]},{"text":"impl ToTokens for Yield","synthetic":false,"types":["syn::token::Yield"]},{"text":"impl ToTokens for Add","synthetic":false,"types":["syn::token::Add"]},{"text":"impl ToTokens for AddEq","synthetic":false,"types":["syn::token::AddEq"]},{"text":"impl ToTokens for And","synthetic":false,"types":["syn::token::And"]},{"text":"impl ToTokens for AndAnd","synthetic":false,"types":["syn::token::AndAnd"]},{"text":"impl ToTokens for AndEq","synthetic":false,"types":["syn::token::AndEq"]},{"text":"impl ToTokens for At","synthetic":false,"types":["syn::token::At"]},{"text":"impl ToTokens for Bang","synthetic":false,"types":["syn::token::Bang"]},{"text":"impl ToTokens for Caret","synthetic":false,"types":["syn::token::Caret"]},{"text":"impl ToTokens for CaretEq","synthetic":false,"types":["syn::token::CaretEq"]},{"text":"impl ToTokens for Colon","synthetic":false,"types":["syn::token::Colon"]},{"text":"impl ToTokens for Colon2","synthetic":false,"types":["syn::token::Colon2"]},{"text":"impl ToTokens for Comma","synthetic":false,"types":["syn::token::Comma"]},{"text":"impl ToTokens for Div","synthetic":false,"types":["syn::token::Div"]},{"text":"impl ToTokens for DivEq","synthetic":false,"types":["syn::token::DivEq"]},{"text":"impl ToTokens for Dollar","synthetic":false,"types":["syn::token::Dollar"]},{"text":"impl ToTokens for Dot","synthetic":false,"types":["syn::token::Dot"]},{"text":"impl ToTokens for Dot2","synthetic":false,"types":["syn::token::Dot2"]},{"text":"impl ToTokens for Dot3","synthetic":false,"types":["syn::token::Dot3"]},{"text":"impl ToTokens for DotDotEq","synthetic":false,"types":["syn::token::DotDotEq"]},{"text":"impl ToTokens for Eq","synthetic":false,"types":["syn::token::Eq"]},{"text":"impl ToTokens for EqEq","synthetic":false,"types":["syn::token::EqEq"]},{"text":"impl ToTokens for Ge","synthetic":false,"types":["syn::token::Ge"]},{"text":"impl ToTokens for Gt","synthetic":false,"types":["syn::token::Gt"]},{"text":"impl ToTokens for Le","synthetic":false,"types":["syn::token::Le"]},{"text":"impl ToTokens for Lt","synthetic":false,"types":["syn::token::Lt"]},{"text":"impl ToTokens for MulEq","synthetic":false,"types":["syn::token::MulEq"]},{"text":"impl ToTokens for Ne","synthetic":false,"types":["syn::token::Ne"]},{"text":"impl ToTokens for Or","synthetic":false,"types":["syn::token::Or"]},{"text":"impl ToTokens for OrEq","synthetic":false,"types":["syn::token::OrEq"]},{"text":"impl ToTokens for OrOr","synthetic":false,"types":["syn::token::OrOr"]},{"text":"impl ToTokens for Pound","synthetic":false,"types":["syn::token::Pound"]},{"text":"impl ToTokens for Question","synthetic":false,"types":["syn::token::Question"]},{"text":"impl ToTokens for RArrow","synthetic":false,"types":["syn::token::RArrow"]},{"text":"impl ToTokens for LArrow","synthetic":false,"types":["syn::token::LArrow"]},{"text":"impl ToTokens for Rem","synthetic":false,"types":["syn::token::Rem"]},{"text":"impl ToTokens for RemEq","synthetic":false,"types":["syn::token::RemEq"]},{"text":"impl ToTokens for FatArrow","synthetic":false,"types":["syn::token::FatArrow"]},{"text":"impl ToTokens for Semi","synthetic":false,"types":["syn::token::Semi"]},{"text":"impl ToTokens for Shl","synthetic":false,"types":["syn::token::Shl"]},{"text":"impl ToTokens for ShlEq","synthetic":false,"types":["syn::token::ShlEq"]},{"text":"impl ToTokens for Shr","synthetic":false,"types":["syn::token::Shr"]},{"text":"impl ToTokens for ShrEq","synthetic":false,"types":["syn::token::ShrEq"]},{"text":"impl ToTokens for Star","synthetic":false,"types":["syn::token::Star"]},{"text":"impl ToTokens for Sub","synthetic":false,"types":["syn::token::Sub"]},{"text":"impl ToTokens for SubEq","synthetic":false,"types":["syn::token::SubEq"]},{"text":"impl ToTokens for Tilde","synthetic":false,"types":["syn::token::Tilde"]},{"text":"impl ToTokens for Meta","synthetic":false,"types":["syn::attr::Meta"]},{"text":"impl ToTokens for NestedMeta","synthetic":false,"types":["syn::attr::NestedMeta"]},{"text":"impl ToTokens for Attribute","synthetic":false,"types":["syn::attr::Attribute"]},{"text":"impl ToTokens for MetaList","synthetic":false,"types":["syn::attr::MetaList"]},{"text":"impl ToTokens for MetaNameValue","synthetic":false,"types":["syn::attr::MetaNameValue"]},{"text":"impl ToTokens for Fields","synthetic":false,"types":["syn::data::Fields"]},{"text":"impl ToTokens for Visibility","synthetic":false,"types":["syn::data::Visibility"]},{"text":"impl ToTokens for Variant","synthetic":false,"types":["syn::data::Variant"]},{"text":"impl ToTokens for FieldsNamed","synthetic":false,"types":["syn::data::FieldsNamed"]},{"text":"impl ToTokens for FieldsUnnamed","synthetic":false,"types":["syn::data::FieldsUnnamed"]},{"text":"impl ToTokens for Field","synthetic":false,"types":["syn::data::Field"]},{"text":"impl ToTokens for VisPublic","synthetic":false,"types":["syn::data::VisPublic"]},{"text":"impl ToTokens for VisCrate","synthetic":false,"types":["syn::data::VisCrate"]},{"text":"impl ToTokens for VisRestricted","synthetic":false,"types":["syn::data::VisRestricted"]},{"text":"impl ToTokens for Expr","synthetic":false,"types":["syn::expr::Expr"]},{"text":"impl ToTokens for ExprArray","synthetic":false,"types":["syn::expr::ExprArray"]},{"text":"impl ToTokens for ExprAssign","synthetic":false,"types":["syn::expr::ExprAssign"]},{"text":"impl ToTokens for ExprAssignOp","synthetic":false,"types":["syn::expr::ExprAssignOp"]},{"text":"impl ToTokens for ExprAsync","synthetic":false,"types":["syn::expr::ExprAsync"]},{"text":"impl ToTokens for ExprAwait","synthetic":false,"types":["syn::expr::ExprAwait"]},{"text":"impl ToTokens for ExprBlock","synthetic":false,"types":["syn::expr::ExprBlock"]},{"text":"impl ToTokens for ExprBox","synthetic":false,"types":["syn::expr::ExprBox"]},{"text":"impl ToTokens for ExprBreak","synthetic":false,"types":["syn::expr::ExprBreak"]},{"text":"impl ToTokens for ExprClosure","synthetic":false,"types":["syn::expr::ExprClosure"]},{"text":"impl ToTokens for ExprContinue","synthetic":false,"types":["syn::expr::ExprContinue"]},{"text":"impl ToTokens for ExprForLoop","synthetic":false,"types":["syn::expr::ExprForLoop"]},{"text":"impl ToTokens for ExprGroup","synthetic":false,"types":["syn::expr::ExprGroup"]},{"text":"impl ToTokens for ExprIf","synthetic":false,"types":["syn::expr::ExprIf"]},{"text":"impl ToTokens for ExprLet","synthetic":false,"types":["syn::expr::ExprLet"]},{"text":"impl ToTokens for ExprLoop","synthetic":false,"types":["syn::expr::ExprLoop"]},{"text":"impl ToTokens for ExprMacro","synthetic":false,"types":["syn::expr::ExprMacro"]},{"text":"impl ToTokens for ExprMatch","synthetic":false,"types":["syn::expr::ExprMatch"]},{"text":"impl ToTokens for ExprMethodCall","synthetic":false,"types":["syn::expr::ExprMethodCall"]},{"text":"impl ToTokens for ExprRange","synthetic":false,"types":["syn::expr::ExprRange"]},{"text":"impl ToTokens for ExprReference","synthetic":false,"types":["syn::expr::ExprReference"]},{"text":"impl ToTokens for ExprRepeat","synthetic":false,"types":["syn::expr::ExprRepeat"]},{"text":"impl ToTokens for ExprReturn","synthetic":false,"types":["syn::expr::ExprReturn"]},{"text":"impl ToTokens for ExprStruct","synthetic":false,"types":["syn::expr::ExprStruct"]},{"text":"impl ToTokens for ExprTry","synthetic":false,"types":["syn::expr::ExprTry"]},{"text":"impl ToTokens for ExprTryBlock","synthetic":false,"types":["syn::expr::ExprTryBlock"]},{"text":"impl ToTokens for ExprTuple","synthetic":false,"types":["syn::expr::ExprTuple"]},{"text":"impl ToTokens for ExprType","synthetic":false,"types":["syn::expr::ExprType"]},{"text":"impl ToTokens for ExprUnsafe","synthetic":false,"types":["syn::expr::ExprUnsafe"]},{"text":"impl ToTokens for ExprWhile","synthetic":false,"types":["syn::expr::ExprWhile"]},{"text":"impl ToTokens for ExprYield","synthetic":false,"types":["syn::expr::ExprYield"]},{"text":"impl ToTokens for ExprCall","synthetic":false,"types":["syn::expr::ExprCall"]},{"text":"impl ToTokens for ExprBinary","synthetic":false,"types":["syn::expr::ExprBinary"]},{"text":"impl ToTokens for ExprUnary","synthetic":false,"types":["syn::expr::ExprUnary"]},{"text":"impl ToTokens for ExprLit","synthetic":false,"types":["syn::expr::ExprLit"]},{"text":"impl ToTokens for ExprCast","synthetic":false,"types":["syn::expr::ExprCast"]},{"text":"impl ToTokens for ExprField","synthetic":false,"types":["syn::expr::ExprField"]},{"text":"impl ToTokens for Member","synthetic":false,"types":["syn::expr::Member"]},{"text":"impl ToTokens for Index","synthetic":false,"types":["syn::expr::Index"]},{"text":"impl ToTokens for ExprIndex","synthetic":false,"types":["syn::expr::ExprIndex"]},{"text":"impl ToTokens for ExprPath","synthetic":false,"types":["syn::expr::ExprPath"]},{"text":"impl ToTokens for ExprParen","synthetic":false,"types":["syn::expr::ExprParen"]},{"text":"impl ToTokens for GenericParam","synthetic":false,"types":["syn::generics::GenericParam"]},{"text":"impl ToTokens for TypeParamBound","synthetic":false,"types":["syn::generics::TypeParamBound"]},{"text":"impl ToTokens for WherePredicate","synthetic":false,"types":["syn::generics::WherePredicate"]},{"text":"impl ToTokens for Generics","synthetic":false,"types":["syn::generics::Generics"]},{"text":"impl<'a> ToTokens for ImplGenerics<'a>","synthetic":false,"types":["syn::generics::ImplGenerics"]},{"text":"impl<'a> ToTokens for TypeGenerics<'a>","synthetic":false,"types":["syn::generics::TypeGenerics"]},{"text":"impl<'a> ToTokens for Turbofish<'a>","synthetic":false,"types":["syn::generics::Turbofish"]},{"text":"impl ToTokens for BoundLifetimes","synthetic":false,"types":["syn::generics::BoundLifetimes"]},{"text":"impl ToTokens for LifetimeDef","synthetic":false,"types":["syn::generics::LifetimeDef"]},{"text":"impl ToTokens for TypeParam","synthetic":false,"types":["syn::generics::TypeParam"]},{"text":"impl ToTokens for TraitBound","synthetic":false,"types":["syn::generics::TraitBound"]},{"text":"impl ToTokens for TraitBoundModifier","synthetic":false,"types":["syn::generics::TraitBoundModifier"]},{"text":"impl ToTokens for ConstParam","synthetic":false,"types":["syn::generics::ConstParam"]},{"text":"impl ToTokens for WhereClause","synthetic":false,"types":["syn::generics::WhereClause"]},{"text":"impl ToTokens for PredicateType","synthetic":false,"types":["syn::generics::PredicateType"]},{"text":"impl ToTokens for PredicateLifetime","synthetic":false,"types":["syn::generics::PredicateLifetime"]},{"text":"impl ToTokens for PredicateEq","synthetic":false,"types":["syn::generics::PredicateEq"]},{"text":"impl ToTokens for Lifetime","synthetic":false,"types":["syn::lifetime::Lifetime"]},{"text":"impl ToTokens for Lit","synthetic":false,"types":["syn::lit::Lit"]},{"text":"impl ToTokens for LitStr","synthetic":false,"types":["syn::lit::LitStr"]},{"text":"impl ToTokens for LitByteStr","synthetic":false,"types":["syn::lit::LitByteStr"]},{"text":"impl ToTokens for LitByte","synthetic":false,"types":["syn::lit::LitByte"]},{"text":"impl ToTokens for LitChar","synthetic":false,"types":["syn::lit::LitChar"]},{"text":"impl ToTokens for LitInt","synthetic":false,"types":["syn::lit::LitInt"]},{"text":"impl ToTokens for LitFloat","synthetic":false,"types":["syn::lit::LitFloat"]},{"text":"impl ToTokens for LitBool","synthetic":false,"types":["syn::lit::LitBool"]},{"text":"impl ToTokens for Macro","synthetic":false,"types":["syn::mac::Macro"]},{"text":"impl ToTokens for DeriveInput","synthetic":false,"types":["syn::derive::DeriveInput"]},{"text":"impl ToTokens for BinOp","synthetic":false,"types":["syn::op::BinOp"]},{"text":"impl ToTokens for UnOp","synthetic":false,"types":["syn::op::UnOp"]},{"text":"impl ToTokens for Type","synthetic":false,"types":["syn::ty::Type"]},{"text":"impl ToTokens for TypeSlice","synthetic":false,"types":["syn::ty::TypeSlice"]},{"text":"impl ToTokens for TypeArray","synthetic":false,"types":["syn::ty::TypeArray"]},{"text":"impl ToTokens for TypePtr","synthetic":false,"types":["syn::ty::TypePtr"]},{"text":"impl ToTokens for TypeReference","synthetic":false,"types":["syn::ty::TypeReference"]},{"text":"impl ToTokens for TypeBareFn","synthetic":false,"types":["syn::ty::TypeBareFn"]},{"text":"impl ToTokens for TypeNever","synthetic":false,"types":["syn::ty::TypeNever"]},{"text":"impl ToTokens for TypeTuple","synthetic":false,"types":["syn::ty::TypeTuple"]},{"text":"impl ToTokens for TypePath","synthetic":false,"types":["syn::ty::TypePath"]},{"text":"impl ToTokens for TypeTraitObject","synthetic":false,"types":["syn::ty::TypeTraitObject"]},{"text":"impl ToTokens for TypeImplTrait","synthetic":false,"types":["syn::ty::TypeImplTrait"]},{"text":"impl ToTokens for TypeGroup","synthetic":false,"types":["syn::ty::TypeGroup"]},{"text":"impl ToTokens for TypeParen","synthetic":false,"types":["syn::ty::TypeParen"]},{"text":"impl ToTokens for TypeInfer","synthetic":false,"types":["syn::ty::TypeInfer"]},{"text":"impl ToTokens for TypeMacro","synthetic":false,"types":["syn::ty::TypeMacro"]},{"text":"impl ToTokens for ReturnType","synthetic":false,"types":["syn::ty::ReturnType"]},{"text":"impl ToTokens for BareFnArg","synthetic":false,"types":["syn::ty::BareFnArg"]},{"text":"impl ToTokens for Variadic","synthetic":false,"types":["syn::ty::Variadic"]},{"text":"impl ToTokens for Abi","synthetic":false,"types":["syn::ty::Abi"]},{"text":"impl ToTokens for Path","synthetic":false,"types":["syn::path::Path"]},{"text":"impl ToTokens for PathSegment","synthetic":false,"types":["syn::path::PathSegment"]},{"text":"impl ToTokens for PathArguments","synthetic":false,"types":["syn::path::PathArguments"]},{"text":"impl ToTokens for GenericArgument","synthetic":false,"types":["syn::path::GenericArgument"]},{"text":"impl ToTokens for AngleBracketedGenericArguments","synthetic":false,"types":["syn::path::AngleBracketedGenericArguments"]},{"text":"impl ToTokens for Binding","synthetic":false,"types":["syn::path::Binding"]},{"text":"impl ToTokens for Constraint","synthetic":false,"types":["syn::path::Constraint"]},{"text":"impl ToTokens for ParenthesizedGenericArguments","synthetic":false,"types":["syn::path::ParenthesizedGenericArguments"]},{"text":"impl<T, P> ToTokens for Punctuated<T, P> where
    T: ToTokens,
    P: ToTokens, ","synthetic":false,"types":["syn::punctuated::Punctuated"]},{"text":"impl<T, P> ToTokens for Pair<T, P> where
    T: ToTokens,
    P: ToTokens, ","synthetic":false,"types":["syn::punctuated::Pair"]}]; +implementors["synstructure"] = [{"text":"impl ToTokens for BindStyle","synthetic":false,"types":["synstructure::BindStyle"]},{"text":"impl<'a> ToTokens for BindingInfo<'a>","synthetic":false,"types":["synstructure::BindingInfo"]}]; if (window.register_implementors) {window.register_implementors(implementors);} else {window.pending_implementors = implementors;}})() \ No newline at end of file diff --git a/implementors/std/error/trait.Error.js b/implementors/std/error/trait.Error.js index 1e888a0..31e9c9c 100644 --- a/implementors/std/error/trait.Error.js +++ b/implementors/std/error/trait.Error.js @@ -1,4 +1,4 @@ (function() {var implementors = {}; -implementors["proc_macro2"] = [{"text":"impl Error for LexError","synthetic":false,"types":[]}]; -implementors["syn"] = [{"text":"impl Error for Error","synthetic":false,"types":[]}]; +implementors["proc_macro2"] = [{"text":"impl Error for LexError","synthetic":false,"types":["proc_macro2::LexError"]}]; +implementors["syn"] = [{"text":"impl Error for Error","synthetic":false,"types":["syn::error::Error"]}]; if (window.register_implementors) {window.register_implementors(implementors);} else {window.pending_implementors = implementors;}})() \ No newline at end of file diff --git a/implementors/std/panic/trait.RefUnwindSafe.js b/implementors/std/panic/trait.RefUnwindSafe.js index 8cb52ec..187d8c4 100644 --- a/implementors/std/panic/trait.RefUnwindSafe.js +++ b/implementors/std/panic/trait.RefUnwindSafe.js @@ -1,5 +1,5 @@ (function() {var implementors = {}; -implementors["proc_macro2"] = [{"text":"impl RefUnwindSafe for IntoIter","synthetic":true,"types":[]},{"text":"impl RefUnwindSafe for TokenStream","synthetic":true,"types":[]},{"text":"impl RefUnwindSafe for LexError","synthetic":true,"types":[]},{"text":"impl RefUnwindSafe for Span","synthetic":true,"types":[]},{"text":"impl RefUnwindSafe for TokenTree","synthetic":true,"types":[]},{"text":"impl RefUnwindSafe for Group","synthetic":true,"types":[]},{"text":"impl RefUnwindSafe for Delimiter","synthetic":true,"types":[]},{"text":"impl RefUnwindSafe for Punct","synthetic":true,"types":[]},{"text":"impl RefUnwindSafe for Spacing","synthetic":true,"types":[]},{"text":"impl RefUnwindSafe for Ident","synthetic":true,"types":[]},{"text":"impl RefUnwindSafe for Literal","synthetic":true,"types":[]}]; -implementors["syn"] = [{"text":"impl RefUnwindSafe for Underscore","synthetic":true,"types":[]},{"text":"impl RefUnwindSafe for Abstract","synthetic":true,"types":[]},{"text":"impl RefUnwindSafe for As","synthetic":true,"types":[]},{"text":"impl RefUnwindSafe for Async","synthetic":true,"types":[]},{"text":"impl RefUnwindSafe for Auto","synthetic":true,"types":[]},{"text":"impl RefUnwindSafe for Await","synthetic":true,"types":[]},{"text":"impl RefUnwindSafe for Become","synthetic":true,"types":[]},{"text":"impl RefUnwindSafe for Box","synthetic":true,"types":[]},{"text":"impl RefUnwindSafe for Break","synthetic":true,"types":[]},{"text":"impl RefUnwindSafe for Const","synthetic":true,"types":[]},{"text":"impl RefUnwindSafe for Continue","synthetic":true,"types":[]},{"text":"impl RefUnwindSafe for Crate","synthetic":true,"types":[]},{"text":"impl RefUnwindSafe for Default","synthetic":true,"types":[]},{"text":"impl RefUnwindSafe for Do","synthetic":true,"types":[]},{"text":"impl RefUnwindSafe for Dyn","synthetic":true,"types":[]},{"text":"impl RefUnwindSafe for Else","synthetic":true,"types":[]},{"text":"impl RefUnwindSafe for Enum","synthetic":true,"types":[]},{"text":"impl RefUnwindSafe for Extern","synthetic":true,"types":[]},{"text":"impl RefUnwindSafe for Final","synthetic":true,"types":[]},{"text":"impl RefUnwindSafe for Fn","synthetic":true,"types":[]},{"text":"impl RefUnwindSafe for For","synthetic":true,"types":[]},{"text":"impl RefUnwindSafe for If","synthetic":true,"types":[]},{"text":"impl RefUnwindSafe for Impl","synthetic":true,"types":[]},{"text":"impl RefUnwindSafe for In","synthetic":true,"types":[]},{"text":"impl RefUnwindSafe for Let","synthetic":true,"types":[]},{"text":"impl RefUnwindSafe for Loop","synthetic":true,"types":[]},{"text":"impl RefUnwindSafe for Macro","synthetic":true,"types":[]},{"text":"impl RefUnwindSafe for Match","synthetic":true,"types":[]},{"text":"impl RefUnwindSafe for Mod","synthetic":true,"types":[]},{"text":"impl RefUnwindSafe for Move","synthetic":true,"types":[]},{"text":"impl RefUnwindSafe for Mut","synthetic":true,"types":[]},{"text":"impl RefUnwindSafe for Override","synthetic":true,"types":[]},{"text":"impl RefUnwindSafe for Priv","synthetic":true,"types":[]},{"text":"impl RefUnwindSafe for Pub","synthetic":true,"types":[]},{"text":"impl RefUnwindSafe for Ref","synthetic":true,"types":[]},{"text":"impl RefUnwindSafe for Return","synthetic":true,"types":[]},{"text":"impl RefUnwindSafe for SelfType","synthetic":true,"types":[]},{"text":"impl RefUnwindSafe for SelfValue","synthetic":true,"types":[]},{"text":"impl RefUnwindSafe for Static","synthetic":true,"types":[]},{"text":"impl RefUnwindSafe for Struct","synthetic":true,"types":[]},{"text":"impl RefUnwindSafe for Super","synthetic":true,"types":[]},{"text":"impl RefUnwindSafe for Trait","synthetic":true,"types":[]},{"text":"impl RefUnwindSafe for Try","synthetic":true,"types":[]},{"text":"impl RefUnwindSafe for Type","synthetic":true,"types":[]},{"text":"impl RefUnwindSafe for Typeof","synthetic":true,"types":[]},{"text":"impl RefUnwindSafe for Union","synthetic":true,"types":[]},{"text":"impl RefUnwindSafe for Unsafe","synthetic":true,"types":[]},{"text":"impl RefUnwindSafe for Unsized","synthetic":true,"types":[]},{"text":"impl RefUnwindSafe for Use","synthetic":true,"types":[]},{"text":"impl RefUnwindSafe for Virtual","synthetic":true,"types":[]},{"text":"impl RefUnwindSafe for Where","synthetic":true,"types":[]},{"text":"impl RefUnwindSafe for While","synthetic":true,"types":[]},{"text":"impl RefUnwindSafe for Yield","synthetic":true,"types":[]},{"text":"impl RefUnwindSafe for Add","synthetic":true,"types":[]},{"text":"impl RefUnwindSafe for AddEq","synthetic":true,"types":[]},{"text":"impl RefUnwindSafe for And","synthetic":true,"types":[]},{"text":"impl RefUnwindSafe for AndAnd","synthetic":true,"types":[]},{"text":"impl RefUnwindSafe for AndEq","synthetic":true,"types":[]},{"text":"impl RefUnwindSafe for At","synthetic":true,"types":[]},{"text":"impl RefUnwindSafe for Bang","synthetic":true,"types":[]},{"text":"impl RefUnwindSafe for Caret","synthetic":true,"types":[]},{"text":"impl RefUnwindSafe for CaretEq","synthetic":true,"types":[]},{"text":"impl RefUnwindSafe for Colon","synthetic":true,"types":[]},{"text":"impl RefUnwindSafe for Colon2","synthetic":true,"types":[]},{"text":"impl RefUnwindSafe for Comma","synthetic":true,"types":[]},{"text":"impl RefUnwindSafe for Div","synthetic":true,"types":[]},{"text":"impl RefUnwindSafe for DivEq","synthetic":true,"types":[]},{"text":"impl RefUnwindSafe for Dollar","synthetic":true,"types":[]},{"text":"impl RefUnwindSafe for Dot","synthetic":true,"types":[]},{"text":"impl RefUnwindSafe for Dot2","synthetic":true,"types":[]},{"text":"impl RefUnwindSafe for Dot3","synthetic":true,"types":[]},{"text":"impl RefUnwindSafe for DotDotEq","synthetic":true,"types":[]},{"text":"impl RefUnwindSafe for Eq","synthetic":true,"types":[]},{"text":"impl RefUnwindSafe for EqEq","synthetic":true,"types":[]},{"text":"impl RefUnwindSafe for Ge","synthetic":true,"types":[]},{"text":"impl RefUnwindSafe for Gt","synthetic":true,"types":[]},{"text":"impl RefUnwindSafe for Le","synthetic":true,"types":[]},{"text":"impl RefUnwindSafe for Lt","synthetic":true,"types":[]},{"text":"impl RefUnwindSafe for MulEq","synthetic":true,"types":[]},{"text":"impl RefUnwindSafe for Ne","synthetic":true,"types":[]},{"text":"impl RefUnwindSafe for Or","synthetic":true,"types":[]},{"text":"impl RefUnwindSafe for OrEq","synthetic":true,"types":[]},{"text":"impl RefUnwindSafe for OrOr","synthetic":true,"types":[]},{"text":"impl RefUnwindSafe for Pound","synthetic":true,"types":[]},{"text":"impl RefUnwindSafe for Question","synthetic":true,"types":[]},{"text":"impl RefUnwindSafe for RArrow","synthetic":true,"types":[]},{"text":"impl RefUnwindSafe for LArrow","synthetic":true,"types":[]},{"text":"impl RefUnwindSafe for Rem","synthetic":true,"types":[]},{"text":"impl RefUnwindSafe for RemEq","synthetic":true,"types":[]},{"text":"impl RefUnwindSafe for FatArrow","synthetic":true,"types":[]},{"text":"impl RefUnwindSafe for Semi","synthetic":true,"types":[]},{"text":"impl RefUnwindSafe for Shl","synthetic":true,"types":[]},{"text":"impl RefUnwindSafe for ShlEq","synthetic":true,"types":[]},{"text":"impl RefUnwindSafe for Shr","synthetic":true,"types":[]},{"text":"impl RefUnwindSafe for ShrEq","synthetic":true,"types":[]},{"text":"impl RefUnwindSafe for Star","synthetic":true,"types":[]},{"text":"impl RefUnwindSafe for Sub","synthetic":true,"types":[]},{"text":"impl RefUnwindSafe for SubEq","synthetic":true,"types":[]},{"text":"impl RefUnwindSafe for Tilde","synthetic":true,"types":[]},{"text":"impl RefUnwindSafe for Brace","synthetic":true,"types":[]},{"text":"impl RefUnwindSafe for Bracket","synthetic":true,"types":[]},{"text":"impl RefUnwindSafe for Paren","synthetic":true,"types":[]},{"text":"impl RefUnwindSafe for Group","synthetic":true,"types":[]},{"text":"impl RefUnwindSafe for Attribute","synthetic":true,"types":[]},{"text":"impl RefUnwindSafe for AttrStyle","synthetic":true,"types":[]},{"text":"impl RefUnwindSafe for Meta","synthetic":true,"types":[]},{"text":"impl RefUnwindSafe for MetaList","synthetic":true,"types":[]},{"text":"impl RefUnwindSafe for MetaNameValue","synthetic":true,"types":[]},{"text":"impl RefUnwindSafe for NestedMeta","synthetic":true,"types":[]},{"text":"impl RefUnwindSafe for Variant","synthetic":true,"types":[]},{"text":"impl RefUnwindSafe for Fields","synthetic":true,"types":[]},{"text":"impl RefUnwindSafe for FieldsNamed","synthetic":true,"types":[]},{"text":"impl RefUnwindSafe for FieldsUnnamed","synthetic":true,"types":[]},{"text":"impl RefUnwindSafe for Field","synthetic":true,"types":[]},{"text":"impl RefUnwindSafe for Visibility","synthetic":true,"types":[]},{"text":"impl RefUnwindSafe for VisPublic","synthetic":true,"types":[]},{"text":"impl RefUnwindSafe for VisCrate","synthetic":true,"types":[]},{"text":"impl RefUnwindSafe for VisRestricted","synthetic":true,"types":[]},{"text":"impl RefUnwindSafe for Expr","synthetic":true,"types":[]},{"text":"impl RefUnwindSafe for ExprArray","synthetic":true,"types":[]},{"text":"impl RefUnwindSafe for ExprAssign","synthetic":true,"types":[]},{"text":"impl RefUnwindSafe for ExprAssignOp","synthetic":true,"types":[]},{"text":"impl RefUnwindSafe for ExprAsync","synthetic":true,"types":[]},{"text":"impl RefUnwindSafe for ExprAwait","synthetic":true,"types":[]},{"text":"impl RefUnwindSafe for ExprBinary","synthetic":true,"types":[]},{"text":"impl RefUnwindSafe for ExprBlock","synthetic":true,"types":[]},{"text":"impl RefUnwindSafe for ExprBox","synthetic":true,"types":[]},{"text":"impl RefUnwindSafe for ExprBreak","synthetic":true,"types":[]},{"text":"impl RefUnwindSafe for ExprCall","synthetic":true,"types":[]},{"text":"impl RefUnwindSafe for ExprCast","synthetic":true,"types":[]},{"text":"impl RefUnwindSafe for ExprClosure","synthetic":true,"types":[]},{"text":"impl RefUnwindSafe for ExprContinue","synthetic":true,"types":[]},{"text":"impl RefUnwindSafe for ExprField","synthetic":true,"types":[]},{"text":"impl RefUnwindSafe for ExprForLoop","synthetic":true,"types":[]},{"text":"impl RefUnwindSafe for ExprGroup","synthetic":true,"types":[]},{"text":"impl RefUnwindSafe for ExprIf","synthetic":true,"types":[]},{"text":"impl RefUnwindSafe for ExprIndex","synthetic":true,"types":[]},{"text":"impl RefUnwindSafe for ExprLet","synthetic":true,"types":[]},{"text":"impl RefUnwindSafe for ExprLit","synthetic":true,"types":[]},{"text":"impl RefUnwindSafe for ExprLoop","synthetic":true,"types":[]},{"text":"impl RefUnwindSafe for ExprMacro","synthetic":true,"types":[]},{"text":"impl RefUnwindSafe for ExprMatch","synthetic":true,"types":[]},{"text":"impl RefUnwindSafe for ExprMethodCall","synthetic":true,"types":[]},{"text":"impl RefUnwindSafe for ExprParen","synthetic":true,"types":[]},{"text":"impl RefUnwindSafe for ExprPath","synthetic":true,"types":[]},{"text":"impl RefUnwindSafe for ExprRange","synthetic":true,"types":[]},{"text":"impl RefUnwindSafe for ExprReference","synthetic":true,"types":[]},{"text":"impl RefUnwindSafe for ExprRepeat","synthetic":true,"types":[]},{"text":"impl RefUnwindSafe for ExprReturn","synthetic":true,"types":[]},{"text":"impl RefUnwindSafe for ExprStruct","synthetic":true,"types":[]},{"text":"impl RefUnwindSafe for ExprTry","synthetic":true,"types":[]},{"text":"impl RefUnwindSafe for ExprTryBlock","synthetic":true,"types":[]},{"text":"impl RefUnwindSafe for ExprTuple","synthetic":true,"types":[]},{"text":"impl RefUnwindSafe for ExprType","synthetic":true,"types":[]},{"text":"impl RefUnwindSafe for ExprUnary","synthetic":true,"types":[]},{"text":"impl RefUnwindSafe for ExprUnsafe","synthetic":true,"types":[]},{"text":"impl RefUnwindSafe for ExprWhile","synthetic":true,"types":[]},{"text":"impl RefUnwindSafe for ExprYield","synthetic":true,"types":[]},{"text":"impl RefUnwindSafe for Member","synthetic":true,"types":[]},{"text":"impl RefUnwindSafe for Index","synthetic":true,"types":[]},{"text":"impl RefUnwindSafe for Generics","synthetic":true,"types":[]},{"text":"impl RefUnwindSafe for GenericParam","synthetic":true,"types":[]},{"text":"impl RefUnwindSafe for TypeParam","synthetic":true,"types":[]},{"text":"impl RefUnwindSafe for LifetimeDef","synthetic":true,"types":[]},{"text":"impl RefUnwindSafe for ConstParam","synthetic":true,"types":[]},{"text":"impl<'a> RefUnwindSafe for ImplGenerics<'a>","synthetic":true,"types":[]},{"text":"impl<'a> RefUnwindSafe for TypeGenerics<'a>","synthetic":true,"types":[]},{"text":"impl<'a> RefUnwindSafe for Turbofish<'a>","synthetic":true,"types":[]},{"text":"impl RefUnwindSafe for BoundLifetimes","synthetic":true,"types":[]},{"text":"impl RefUnwindSafe for TypeParamBound","synthetic":true,"types":[]},{"text":"impl RefUnwindSafe for TraitBound","synthetic":true,"types":[]},{"text":"impl RefUnwindSafe for TraitBoundModifier","synthetic":true,"types":[]},{"text":"impl RefUnwindSafe for WhereClause","synthetic":true,"types":[]},{"text":"impl RefUnwindSafe for WherePredicate","synthetic":true,"types":[]},{"text":"impl RefUnwindSafe for PredicateType","synthetic":true,"types":[]},{"text":"impl RefUnwindSafe for PredicateLifetime","synthetic":true,"types":[]},{"text":"impl RefUnwindSafe for PredicateEq","synthetic":true,"types":[]},{"text":"impl RefUnwindSafe for Lifetime","synthetic":true,"types":[]},{"text":"impl RefUnwindSafe for Lit","synthetic":true,"types":[]},{"text":"impl RefUnwindSafe for LitStr","synthetic":true,"types":[]},{"text":"impl RefUnwindSafe for LitByteStr","synthetic":true,"types":[]},{"text":"impl RefUnwindSafe for LitByte","synthetic":true,"types":[]},{"text":"impl RefUnwindSafe for LitChar","synthetic":true,"types":[]},{"text":"impl RefUnwindSafe for LitInt","synthetic":true,"types":[]},{"text":"impl RefUnwindSafe for LitFloat","synthetic":true,"types":[]},{"text":"impl RefUnwindSafe for LitBool","synthetic":true,"types":[]},{"text":"impl RefUnwindSafe for StrStyle","synthetic":true,"types":[]},{"text":"impl RefUnwindSafe for Macro","synthetic":true,"types":[]},{"text":"impl RefUnwindSafe for MacroDelimiter","synthetic":true,"types":[]},{"text":"impl RefUnwindSafe for DeriveInput","synthetic":true,"types":[]},{"text":"impl RefUnwindSafe for Data","synthetic":true,"types":[]},{"text":"impl RefUnwindSafe for DataStruct","synthetic":true,"types":[]},{"text":"impl RefUnwindSafe for DataEnum","synthetic":true,"types":[]},{"text":"impl RefUnwindSafe for DataUnion","synthetic":true,"types":[]},{"text":"impl RefUnwindSafe for BinOp","synthetic":true,"types":[]},{"text":"impl RefUnwindSafe for UnOp","synthetic":true,"types":[]},{"text":"impl RefUnwindSafe for Type","synthetic":true,"types":[]},{"text":"impl RefUnwindSafe for TypeArray","synthetic":true,"types":[]},{"text":"impl RefUnwindSafe for TypeBareFn","synthetic":true,"types":[]},{"text":"impl RefUnwindSafe for TypeGroup","synthetic":true,"types":[]},{"text":"impl RefUnwindSafe for TypeImplTrait","synthetic":true,"types":[]},{"text":"impl RefUnwindSafe for TypeInfer","synthetic":true,"types":[]},{"text":"impl RefUnwindSafe for TypeMacro","synthetic":true,"types":[]},{"text":"impl RefUnwindSafe for TypeNever","synthetic":true,"types":[]},{"text":"impl RefUnwindSafe for TypeParen","synthetic":true,"types":[]},{"text":"impl RefUnwindSafe for TypePath","synthetic":true,"types":[]},{"text":"impl RefUnwindSafe for TypePtr","synthetic":true,"types":[]},{"text":"impl RefUnwindSafe for TypeReference","synthetic":true,"types":[]},{"text":"impl RefUnwindSafe for TypeSlice","synthetic":true,"types":[]},{"text":"impl RefUnwindSafe for TypeTraitObject","synthetic":true,"types":[]},{"text":"impl RefUnwindSafe for TypeTuple","synthetic":true,"types":[]},{"text":"impl RefUnwindSafe for Abi","synthetic":true,"types":[]},{"text":"impl RefUnwindSafe for BareFnArg","synthetic":true,"types":[]},{"text":"impl RefUnwindSafe for Variadic","synthetic":true,"types":[]},{"text":"impl RefUnwindSafe for ReturnType","synthetic":true,"types":[]},{"text":"impl RefUnwindSafe for Path","synthetic":true,"types":[]},{"text":"impl RefUnwindSafe for PathSegment","synthetic":true,"types":[]},{"text":"impl RefUnwindSafe for PathArguments","synthetic":true,"types":[]},{"text":"impl RefUnwindSafe for GenericArgument","synthetic":true,"types":[]},{"text":"impl RefUnwindSafe for AngleBracketedGenericArguments","synthetic":true,"types":[]},{"text":"impl RefUnwindSafe for Binding","synthetic":true,"types":[]},{"text":"impl RefUnwindSafe for Constraint","synthetic":true,"types":[]},{"text":"impl RefUnwindSafe for ParenthesizedGenericArguments","synthetic":true,"types":[]},{"text":"impl RefUnwindSafe for QSelf","synthetic":true,"types":[]},{"text":"impl RefUnwindSafe for TokenBuffer","synthetic":true,"types":[]},{"text":"impl<'a> RefUnwindSafe for Cursor<'a>","synthetic":true,"types":[]},{"text":"impl<T, P> RefUnwindSafe for Punctuated<T, P> where
    P: RefUnwindSafe,
    T: RefUnwindSafe, ","synthetic":true,"types":[]},{"text":"impl<'a, T, P> RefUnwindSafe for Pairs<'a, T, P> where
    P: RefUnwindSafe,
    T: RefUnwindSafe, ","synthetic":true,"types":[]},{"text":"impl<'a, T, P> RefUnwindSafe for PairsMut<'a, T, P> where
    P: RefUnwindSafe,
    T: RefUnwindSafe, ","synthetic":true,"types":[]},{"text":"impl<T, P> RefUnwindSafe for IntoPairs<T, P> where
    P: RefUnwindSafe,
    T: RefUnwindSafe, ","synthetic":true,"types":[]},{"text":"impl<T> RefUnwindSafe for IntoIter<T> where
    T: RefUnwindSafe, ","synthetic":true,"types":[]},{"text":"impl<'a, T> !RefUnwindSafe for Iter<'a, T>","synthetic":true,"types":[]},{"text":"impl<'a, T> !RefUnwindSafe for IterMut<'a, T>","synthetic":true,"types":[]},{"text":"impl<T, P> RefUnwindSafe for Pair<T, P> where
    P: RefUnwindSafe,
    T: RefUnwindSafe, ","synthetic":true,"types":[]},{"text":"impl<'a> !RefUnwindSafe for Lookahead1<'a>","synthetic":true,"types":[]},{"text":"impl RefUnwindSafe for Error","synthetic":true,"types":[]},{"text":"impl<'a> !RefUnwindSafe for ParseBuffer<'a>","synthetic":true,"types":[]},{"text":"impl<'c, 'a> RefUnwindSafe for StepCursor<'c, 'a>","synthetic":true,"types":[]},{"text":"impl RefUnwindSafe for Nothing","synthetic":true,"types":[]}]; -implementors["synstructure"] = [{"text":"impl RefUnwindSafe for AddBounds","synthetic":true,"types":[]},{"text":"impl RefUnwindSafe for BindStyle","synthetic":true,"types":[]},{"text":"impl<'a> RefUnwindSafe for BindingInfo<'a>","synthetic":true,"types":[]},{"text":"impl<'a> RefUnwindSafe for VariantAst<'a>","synthetic":true,"types":[]},{"text":"impl<'a> RefUnwindSafe for VariantInfo<'a>","synthetic":true,"types":[]},{"text":"impl<'a> RefUnwindSafe for Structure<'a>","synthetic":true,"types":[]}]; +implementors["proc_macro2"] = [{"text":"impl RefUnwindSafe for IntoIter","synthetic":true,"types":["proc_macro2::token_stream::IntoIter"]},{"text":"impl RefUnwindSafe for TokenStream","synthetic":true,"types":["proc_macro2::TokenStream"]},{"text":"impl RefUnwindSafe for LexError","synthetic":true,"types":["proc_macro2::LexError"]},{"text":"impl RefUnwindSafe for Span","synthetic":true,"types":["proc_macro2::Span"]},{"text":"impl RefUnwindSafe for TokenTree","synthetic":true,"types":["proc_macro2::TokenTree"]},{"text":"impl RefUnwindSafe for Group","synthetic":true,"types":["proc_macro2::Group"]},{"text":"impl RefUnwindSafe for Delimiter","synthetic":true,"types":["proc_macro2::Delimiter"]},{"text":"impl RefUnwindSafe for Punct","synthetic":true,"types":["proc_macro2::Punct"]},{"text":"impl RefUnwindSafe for Spacing","synthetic":true,"types":["proc_macro2::Spacing"]},{"text":"impl RefUnwindSafe for Ident","synthetic":true,"types":["proc_macro2::Ident"]},{"text":"impl RefUnwindSafe for Literal","synthetic":true,"types":["proc_macro2::Literal"]}]; +implementors["syn"] = [{"text":"impl RefUnwindSafe for Underscore","synthetic":true,"types":["syn::token::Underscore"]},{"text":"impl RefUnwindSafe for Abstract","synthetic":true,"types":["syn::token::Abstract"]},{"text":"impl RefUnwindSafe for As","synthetic":true,"types":["syn::token::As"]},{"text":"impl RefUnwindSafe for Async","synthetic":true,"types":["syn::token::Async"]},{"text":"impl RefUnwindSafe for Auto","synthetic":true,"types":["syn::token::Auto"]},{"text":"impl RefUnwindSafe for Await","synthetic":true,"types":["syn::token::Await"]},{"text":"impl RefUnwindSafe for Become","synthetic":true,"types":["syn::token::Become"]},{"text":"impl RefUnwindSafe for Box","synthetic":true,"types":["syn::token::Box"]},{"text":"impl RefUnwindSafe for Break","synthetic":true,"types":["syn::token::Break"]},{"text":"impl RefUnwindSafe for Const","synthetic":true,"types":["syn::token::Const"]},{"text":"impl RefUnwindSafe for Continue","synthetic":true,"types":["syn::token::Continue"]},{"text":"impl RefUnwindSafe for Crate","synthetic":true,"types":["syn::token::Crate"]},{"text":"impl RefUnwindSafe for Default","synthetic":true,"types":["syn::token::Default"]},{"text":"impl RefUnwindSafe for Do","synthetic":true,"types":["syn::token::Do"]},{"text":"impl RefUnwindSafe for Dyn","synthetic":true,"types":["syn::token::Dyn"]},{"text":"impl RefUnwindSafe for Else","synthetic":true,"types":["syn::token::Else"]},{"text":"impl RefUnwindSafe for Enum","synthetic":true,"types":["syn::token::Enum"]},{"text":"impl RefUnwindSafe for Extern","synthetic":true,"types":["syn::token::Extern"]},{"text":"impl RefUnwindSafe for Final","synthetic":true,"types":["syn::token::Final"]},{"text":"impl RefUnwindSafe for Fn","synthetic":true,"types":["syn::token::Fn"]},{"text":"impl RefUnwindSafe for For","synthetic":true,"types":["syn::token::For"]},{"text":"impl RefUnwindSafe for If","synthetic":true,"types":["syn::token::If"]},{"text":"impl RefUnwindSafe for Impl","synthetic":true,"types":["syn::token::Impl"]},{"text":"impl RefUnwindSafe for In","synthetic":true,"types":["syn::token::In"]},{"text":"impl RefUnwindSafe for Let","synthetic":true,"types":["syn::token::Let"]},{"text":"impl RefUnwindSafe for Loop","synthetic":true,"types":["syn::token::Loop"]},{"text":"impl RefUnwindSafe for Macro","synthetic":true,"types":["syn::token::Macro"]},{"text":"impl RefUnwindSafe for Match","synthetic":true,"types":["syn::token::Match"]},{"text":"impl RefUnwindSafe for Mod","synthetic":true,"types":["syn::token::Mod"]},{"text":"impl RefUnwindSafe for Move","synthetic":true,"types":["syn::token::Move"]},{"text":"impl RefUnwindSafe for Mut","synthetic":true,"types":["syn::token::Mut"]},{"text":"impl RefUnwindSafe for Override","synthetic":true,"types":["syn::token::Override"]},{"text":"impl RefUnwindSafe for Priv","synthetic":true,"types":["syn::token::Priv"]},{"text":"impl RefUnwindSafe for Pub","synthetic":true,"types":["syn::token::Pub"]},{"text":"impl RefUnwindSafe for Ref","synthetic":true,"types":["syn::token::Ref"]},{"text":"impl RefUnwindSafe for Return","synthetic":true,"types":["syn::token::Return"]},{"text":"impl RefUnwindSafe for SelfType","synthetic":true,"types":["syn::token::SelfType"]},{"text":"impl RefUnwindSafe for SelfValue","synthetic":true,"types":["syn::token::SelfValue"]},{"text":"impl RefUnwindSafe for Static","synthetic":true,"types":["syn::token::Static"]},{"text":"impl RefUnwindSafe for Struct","synthetic":true,"types":["syn::token::Struct"]},{"text":"impl RefUnwindSafe for Super","synthetic":true,"types":["syn::token::Super"]},{"text":"impl RefUnwindSafe for Trait","synthetic":true,"types":["syn::token::Trait"]},{"text":"impl RefUnwindSafe for Try","synthetic":true,"types":["syn::token::Try"]},{"text":"impl RefUnwindSafe for Type","synthetic":true,"types":["syn::token::Type"]},{"text":"impl RefUnwindSafe for Typeof","synthetic":true,"types":["syn::token::Typeof"]},{"text":"impl RefUnwindSafe for Union","synthetic":true,"types":["syn::token::Union"]},{"text":"impl RefUnwindSafe for Unsafe","synthetic":true,"types":["syn::token::Unsafe"]},{"text":"impl RefUnwindSafe for Unsized","synthetic":true,"types":["syn::token::Unsized"]},{"text":"impl RefUnwindSafe for Use","synthetic":true,"types":["syn::token::Use"]},{"text":"impl RefUnwindSafe for Virtual","synthetic":true,"types":["syn::token::Virtual"]},{"text":"impl RefUnwindSafe for Where","synthetic":true,"types":["syn::token::Where"]},{"text":"impl RefUnwindSafe for While","synthetic":true,"types":["syn::token::While"]},{"text":"impl RefUnwindSafe for Yield","synthetic":true,"types":["syn::token::Yield"]},{"text":"impl RefUnwindSafe for Add","synthetic":true,"types":["syn::token::Add"]},{"text":"impl RefUnwindSafe for AddEq","synthetic":true,"types":["syn::token::AddEq"]},{"text":"impl RefUnwindSafe for And","synthetic":true,"types":["syn::token::And"]},{"text":"impl RefUnwindSafe for AndAnd","synthetic":true,"types":["syn::token::AndAnd"]},{"text":"impl RefUnwindSafe for AndEq","synthetic":true,"types":["syn::token::AndEq"]},{"text":"impl RefUnwindSafe for At","synthetic":true,"types":["syn::token::At"]},{"text":"impl RefUnwindSafe for Bang","synthetic":true,"types":["syn::token::Bang"]},{"text":"impl RefUnwindSafe for Caret","synthetic":true,"types":["syn::token::Caret"]},{"text":"impl RefUnwindSafe for CaretEq","synthetic":true,"types":["syn::token::CaretEq"]},{"text":"impl RefUnwindSafe for Colon","synthetic":true,"types":["syn::token::Colon"]},{"text":"impl RefUnwindSafe for Colon2","synthetic":true,"types":["syn::token::Colon2"]},{"text":"impl RefUnwindSafe for Comma","synthetic":true,"types":["syn::token::Comma"]},{"text":"impl RefUnwindSafe for Div","synthetic":true,"types":["syn::token::Div"]},{"text":"impl RefUnwindSafe for DivEq","synthetic":true,"types":["syn::token::DivEq"]},{"text":"impl RefUnwindSafe for Dollar","synthetic":true,"types":["syn::token::Dollar"]},{"text":"impl RefUnwindSafe for Dot","synthetic":true,"types":["syn::token::Dot"]},{"text":"impl RefUnwindSafe for Dot2","synthetic":true,"types":["syn::token::Dot2"]},{"text":"impl RefUnwindSafe for Dot3","synthetic":true,"types":["syn::token::Dot3"]},{"text":"impl RefUnwindSafe for DotDotEq","synthetic":true,"types":["syn::token::DotDotEq"]},{"text":"impl RefUnwindSafe for Eq","synthetic":true,"types":["syn::token::Eq"]},{"text":"impl RefUnwindSafe for EqEq","synthetic":true,"types":["syn::token::EqEq"]},{"text":"impl RefUnwindSafe for Ge","synthetic":true,"types":["syn::token::Ge"]},{"text":"impl RefUnwindSafe for Gt","synthetic":true,"types":["syn::token::Gt"]},{"text":"impl RefUnwindSafe for Le","synthetic":true,"types":["syn::token::Le"]},{"text":"impl RefUnwindSafe for Lt","synthetic":true,"types":["syn::token::Lt"]},{"text":"impl RefUnwindSafe for MulEq","synthetic":true,"types":["syn::token::MulEq"]},{"text":"impl RefUnwindSafe for Ne","synthetic":true,"types":["syn::token::Ne"]},{"text":"impl RefUnwindSafe for Or","synthetic":true,"types":["syn::token::Or"]},{"text":"impl RefUnwindSafe for OrEq","synthetic":true,"types":["syn::token::OrEq"]},{"text":"impl RefUnwindSafe for OrOr","synthetic":true,"types":["syn::token::OrOr"]},{"text":"impl RefUnwindSafe for Pound","synthetic":true,"types":["syn::token::Pound"]},{"text":"impl RefUnwindSafe for Question","synthetic":true,"types":["syn::token::Question"]},{"text":"impl RefUnwindSafe for RArrow","synthetic":true,"types":["syn::token::RArrow"]},{"text":"impl RefUnwindSafe for LArrow","synthetic":true,"types":["syn::token::LArrow"]},{"text":"impl RefUnwindSafe for Rem","synthetic":true,"types":["syn::token::Rem"]},{"text":"impl RefUnwindSafe for RemEq","synthetic":true,"types":["syn::token::RemEq"]},{"text":"impl RefUnwindSafe for FatArrow","synthetic":true,"types":["syn::token::FatArrow"]},{"text":"impl RefUnwindSafe for Semi","synthetic":true,"types":["syn::token::Semi"]},{"text":"impl RefUnwindSafe for Shl","synthetic":true,"types":["syn::token::Shl"]},{"text":"impl RefUnwindSafe for ShlEq","synthetic":true,"types":["syn::token::ShlEq"]},{"text":"impl RefUnwindSafe for Shr","synthetic":true,"types":["syn::token::Shr"]},{"text":"impl RefUnwindSafe for ShrEq","synthetic":true,"types":["syn::token::ShrEq"]},{"text":"impl RefUnwindSafe for Star","synthetic":true,"types":["syn::token::Star"]},{"text":"impl RefUnwindSafe for Sub","synthetic":true,"types":["syn::token::Sub"]},{"text":"impl RefUnwindSafe for SubEq","synthetic":true,"types":["syn::token::SubEq"]},{"text":"impl RefUnwindSafe for Tilde","synthetic":true,"types":["syn::token::Tilde"]},{"text":"impl RefUnwindSafe for Brace","synthetic":true,"types":["syn::token::Brace"]},{"text":"impl RefUnwindSafe for Bracket","synthetic":true,"types":["syn::token::Bracket"]},{"text":"impl RefUnwindSafe for Paren","synthetic":true,"types":["syn::token::Paren"]},{"text":"impl RefUnwindSafe for Group","synthetic":true,"types":["syn::token::Group"]},{"text":"impl RefUnwindSafe for Attribute","synthetic":true,"types":["syn::attr::Attribute"]},{"text":"impl RefUnwindSafe for AttrStyle","synthetic":true,"types":["syn::attr::AttrStyle"]},{"text":"impl RefUnwindSafe for Meta","synthetic":true,"types":["syn::attr::Meta"]},{"text":"impl RefUnwindSafe for MetaList","synthetic":true,"types":["syn::attr::MetaList"]},{"text":"impl RefUnwindSafe for MetaNameValue","synthetic":true,"types":["syn::attr::MetaNameValue"]},{"text":"impl RefUnwindSafe for NestedMeta","synthetic":true,"types":["syn::attr::NestedMeta"]},{"text":"impl RefUnwindSafe for Variant","synthetic":true,"types":["syn::data::Variant"]},{"text":"impl RefUnwindSafe for Fields","synthetic":true,"types":["syn::data::Fields"]},{"text":"impl RefUnwindSafe for FieldsNamed","synthetic":true,"types":["syn::data::FieldsNamed"]},{"text":"impl RefUnwindSafe for FieldsUnnamed","synthetic":true,"types":["syn::data::FieldsUnnamed"]},{"text":"impl RefUnwindSafe for Field","synthetic":true,"types":["syn::data::Field"]},{"text":"impl RefUnwindSafe for Visibility","synthetic":true,"types":["syn::data::Visibility"]},{"text":"impl RefUnwindSafe for VisPublic","synthetic":true,"types":["syn::data::VisPublic"]},{"text":"impl RefUnwindSafe for VisCrate","synthetic":true,"types":["syn::data::VisCrate"]},{"text":"impl RefUnwindSafe for VisRestricted","synthetic":true,"types":["syn::data::VisRestricted"]},{"text":"impl RefUnwindSafe for Expr","synthetic":true,"types":["syn::expr::Expr"]},{"text":"impl RefUnwindSafe for ExprArray","synthetic":true,"types":["syn::expr::ExprArray"]},{"text":"impl RefUnwindSafe for ExprAssign","synthetic":true,"types":["syn::expr::ExprAssign"]},{"text":"impl RefUnwindSafe for ExprAssignOp","synthetic":true,"types":["syn::expr::ExprAssignOp"]},{"text":"impl RefUnwindSafe for ExprAsync","synthetic":true,"types":["syn::expr::ExprAsync"]},{"text":"impl RefUnwindSafe for ExprAwait","synthetic":true,"types":["syn::expr::ExprAwait"]},{"text":"impl RefUnwindSafe for ExprBinary","synthetic":true,"types":["syn::expr::ExprBinary"]},{"text":"impl RefUnwindSafe for ExprBlock","synthetic":true,"types":["syn::expr::ExprBlock"]},{"text":"impl RefUnwindSafe for ExprBox","synthetic":true,"types":["syn::expr::ExprBox"]},{"text":"impl RefUnwindSafe for ExprBreak","synthetic":true,"types":["syn::expr::ExprBreak"]},{"text":"impl RefUnwindSafe for ExprCall","synthetic":true,"types":["syn::expr::ExprCall"]},{"text":"impl RefUnwindSafe for ExprCast","synthetic":true,"types":["syn::expr::ExprCast"]},{"text":"impl RefUnwindSafe for ExprClosure","synthetic":true,"types":["syn::expr::ExprClosure"]},{"text":"impl RefUnwindSafe for ExprContinue","synthetic":true,"types":["syn::expr::ExprContinue"]},{"text":"impl RefUnwindSafe for ExprField","synthetic":true,"types":["syn::expr::ExprField"]},{"text":"impl RefUnwindSafe for ExprForLoop","synthetic":true,"types":["syn::expr::ExprForLoop"]},{"text":"impl RefUnwindSafe for ExprGroup","synthetic":true,"types":["syn::expr::ExprGroup"]},{"text":"impl RefUnwindSafe for ExprIf","synthetic":true,"types":["syn::expr::ExprIf"]},{"text":"impl RefUnwindSafe for ExprIndex","synthetic":true,"types":["syn::expr::ExprIndex"]},{"text":"impl RefUnwindSafe for ExprLet","synthetic":true,"types":["syn::expr::ExprLet"]},{"text":"impl RefUnwindSafe for ExprLit","synthetic":true,"types":["syn::expr::ExprLit"]},{"text":"impl RefUnwindSafe for ExprLoop","synthetic":true,"types":["syn::expr::ExprLoop"]},{"text":"impl RefUnwindSafe for ExprMacro","synthetic":true,"types":["syn::expr::ExprMacro"]},{"text":"impl RefUnwindSafe for ExprMatch","synthetic":true,"types":["syn::expr::ExprMatch"]},{"text":"impl RefUnwindSafe for ExprMethodCall","synthetic":true,"types":["syn::expr::ExprMethodCall"]},{"text":"impl RefUnwindSafe for ExprParen","synthetic":true,"types":["syn::expr::ExprParen"]},{"text":"impl RefUnwindSafe for ExprPath","synthetic":true,"types":["syn::expr::ExprPath"]},{"text":"impl RefUnwindSafe for ExprRange","synthetic":true,"types":["syn::expr::ExprRange"]},{"text":"impl RefUnwindSafe for ExprReference","synthetic":true,"types":["syn::expr::ExprReference"]},{"text":"impl RefUnwindSafe for ExprRepeat","synthetic":true,"types":["syn::expr::ExprRepeat"]},{"text":"impl RefUnwindSafe for ExprReturn","synthetic":true,"types":["syn::expr::ExprReturn"]},{"text":"impl RefUnwindSafe for ExprStruct","synthetic":true,"types":["syn::expr::ExprStruct"]},{"text":"impl RefUnwindSafe for ExprTry","synthetic":true,"types":["syn::expr::ExprTry"]},{"text":"impl RefUnwindSafe for ExprTryBlock","synthetic":true,"types":["syn::expr::ExprTryBlock"]},{"text":"impl RefUnwindSafe for ExprTuple","synthetic":true,"types":["syn::expr::ExprTuple"]},{"text":"impl RefUnwindSafe for ExprType","synthetic":true,"types":["syn::expr::ExprType"]},{"text":"impl RefUnwindSafe for ExprUnary","synthetic":true,"types":["syn::expr::ExprUnary"]},{"text":"impl RefUnwindSafe for ExprUnsafe","synthetic":true,"types":["syn::expr::ExprUnsafe"]},{"text":"impl RefUnwindSafe for ExprWhile","synthetic":true,"types":["syn::expr::ExprWhile"]},{"text":"impl RefUnwindSafe for ExprYield","synthetic":true,"types":["syn::expr::ExprYield"]},{"text":"impl RefUnwindSafe for Member","synthetic":true,"types":["syn::expr::Member"]},{"text":"impl RefUnwindSafe for Index","synthetic":true,"types":["syn::expr::Index"]},{"text":"impl RefUnwindSafe for Generics","synthetic":true,"types":["syn::generics::Generics"]},{"text":"impl RefUnwindSafe for GenericParam","synthetic":true,"types":["syn::generics::GenericParam"]},{"text":"impl RefUnwindSafe for TypeParam","synthetic":true,"types":["syn::generics::TypeParam"]},{"text":"impl RefUnwindSafe for LifetimeDef","synthetic":true,"types":["syn::generics::LifetimeDef"]},{"text":"impl RefUnwindSafe for ConstParam","synthetic":true,"types":["syn::generics::ConstParam"]},{"text":"impl<'a> RefUnwindSafe for ImplGenerics<'a>","synthetic":true,"types":["syn::generics::ImplGenerics"]},{"text":"impl<'a> RefUnwindSafe for TypeGenerics<'a>","synthetic":true,"types":["syn::generics::TypeGenerics"]},{"text":"impl<'a> RefUnwindSafe for Turbofish<'a>","synthetic":true,"types":["syn::generics::Turbofish"]},{"text":"impl RefUnwindSafe for BoundLifetimes","synthetic":true,"types":["syn::generics::BoundLifetimes"]},{"text":"impl RefUnwindSafe for TypeParamBound","synthetic":true,"types":["syn::generics::TypeParamBound"]},{"text":"impl RefUnwindSafe for TraitBound","synthetic":true,"types":["syn::generics::TraitBound"]},{"text":"impl RefUnwindSafe for TraitBoundModifier","synthetic":true,"types":["syn::generics::TraitBoundModifier"]},{"text":"impl RefUnwindSafe for WhereClause","synthetic":true,"types":["syn::generics::WhereClause"]},{"text":"impl RefUnwindSafe for WherePredicate","synthetic":true,"types":["syn::generics::WherePredicate"]},{"text":"impl RefUnwindSafe for PredicateType","synthetic":true,"types":["syn::generics::PredicateType"]},{"text":"impl RefUnwindSafe for PredicateLifetime","synthetic":true,"types":["syn::generics::PredicateLifetime"]},{"text":"impl RefUnwindSafe for PredicateEq","synthetic":true,"types":["syn::generics::PredicateEq"]},{"text":"impl RefUnwindSafe for Lifetime","synthetic":true,"types":["syn::lifetime::Lifetime"]},{"text":"impl RefUnwindSafe for Lit","synthetic":true,"types":["syn::lit::Lit"]},{"text":"impl RefUnwindSafe for LitStr","synthetic":true,"types":["syn::lit::LitStr"]},{"text":"impl RefUnwindSafe for LitByteStr","synthetic":true,"types":["syn::lit::LitByteStr"]},{"text":"impl RefUnwindSafe for LitByte","synthetic":true,"types":["syn::lit::LitByte"]},{"text":"impl RefUnwindSafe for LitChar","synthetic":true,"types":["syn::lit::LitChar"]},{"text":"impl RefUnwindSafe for LitInt","synthetic":true,"types":["syn::lit::LitInt"]},{"text":"impl RefUnwindSafe for LitFloat","synthetic":true,"types":["syn::lit::LitFloat"]},{"text":"impl RefUnwindSafe for LitBool","synthetic":true,"types":["syn::lit::LitBool"]},{"text":"impl RefUnwindSafe for StrStyle","synthetic":true,"types":["syn::lit::StrStyle"]},{"text":"impl RefUnwindSafe for Macro","synthetic":true,"types":["syn::mac::Macro"]},{"text":"impl RefUnwindSafe for MacroDelimiter","synthetic":true,"types":["syn::mac::MacroDelimiter"]},{"text":"impl RefUnwindSafe for DeriveInput","synthetic":true,"types":["syn::derive::DeriveInput"]},{"text":"impl RefUnwindSafe for Data","synthetic":true,"types":["syn::derive::Data"]},{"text":"impl RefUnwindSafe for DataStruct","synthetic":true,"types":["syn::derive::DataStruct"]},{"text":"impl RefUnwindSafe for DataEnum","synthetic":true,"types":["syn::derive::DataEnum"]},{"text":"impl RefUnwindSafe for DataUnion","synthetic":true,"types":["syn::derive::DataUnion"]},{"text":"impl RefUnwindSafe for BinOp","synthetic":true,"types":["syn::op::BinOp"]},{"text":"impl RefUnwindSafe for UnOp","synthetic":true,"types":["syn::op::UnOp"]},{"text":"impl RefUnwindSafe for Type","synthetic":true,"types":["syn::ty::Type"]},{"text":"impl RefUnwindSafe for TypeArray","synthetic":true,"types":["syn::ty::TypeArray"]},{"text":"impl RefUnwindSafe for TypeBareFn","synthetic":true,"types":["syn::ty::TypeBareFn"]},{"text":"impl RefUnwindSafe for TypeGroup","synthetic":true,"types":["syn::ty::TypeGroup"]},{"text":"impl RefUnwindSafe for TypeImplTrait","synthetic":true,"types":["syn::ty::TypeImplTrait"]},{"text":"impl RefUnwindSafe for TypeInfer","synthetic":true,"types":["syn::ty::TypeInfer"]},{"text":"impl RefUnwindSafe for TypeMacro","synthetic":true,"types":["syn::ty::TypeMacro"]},{"text":"impl RefUnwindSafe for TypeNever","synthetic":true,"types":["syn::ty::TypeNever"]},{"text":"impl RefUnwindSafe for TypeParen","synthetic":true,"types":["syn::ty::TypeParen"]},{"text":"impl RefUnwindSafe for TypePath","synthetic":true,"types":["syn::ty::TypePath"]},{"text":"impl RefUnwindSafe for TypePtr","synthetic":true,"types":["syn::ty::TypePtr"]},{"text":"impl RefUnwindSafe for TypeReference","synthetic":true,"types":["syn::ty::TypeReference"]},{"text":"impl RefUnwindSafe for TypeSlice","synthetic":true,"types":["syn::ty::TypeSlice"]},{"text":"impl RefUnwindSafe for TypeTraitObject","synthetic":true,"types":["syn::ty::TypeTraitObject"]},{"text":"impl RefUnwindSafe for TypeTuple","synthetic":true,"types":["syn::ty::TypeTuple"]},{"text":"impl RefUnwindSafe for Abi","synthetic":true,"types":["syn::ty::Abi"]},{"text":"impl RefUnwindSafe for BareFnArg","synthetic":true,"types":["syn::ty::BareFnArg"]},{"text":"impl RefUnwindSafe for Variadic","synthetic":true,"types":["syn::ty::Variadic"]},{"text":"impl RefUnwindSafe for ReturnType","synthetic":true,"types":["syn::ty::ReturnType"]},{"text":"impl RefUnwindSafe for Path","synthetic":true,"types":["syn::path::Path"]},{"text":"impl RefUnwindSafe for PathSegment","synthetic":true,"types":["syn::path::PathSegment"]},{"text":"impl RefUnwindSafe for PathArguments","synthetic":true,"types":["syn::path::PathArguments"]},{"text":"impl RefUnwindSafe for GenericArgument","synthetic":true,"types":["syn::path::GenericArgument"]},{"text":"impl RefUnwindSafe for AngleBracketedGenericArguments","synthetic":true,"types":["syn::path::AngleBracketedGenericArguments"]},{"text":"impl RefUnwindSafe for Binding","synthetic":true,"types":["syn::path::Binding"]},{"text":"impl RefUnwindSafe for Constraint","synthetic":true,"types":["syn::path::Constraint"]},{"text":"impl RefUnwindSafe for ParenthesizedGenericArguments","synthetic":true,"types":["syn::path::ParenthesizedGenericArguments"]},{"text":"impl RefUnwindSafe for QSelf","synthetic":true,"types":["syn::path::QSelf"]},{"text":"impl RefUnwindSafe for TokenBuffer","synthetic":true,"types":["syn::buffer::TokenBuffer"]},{"text":"impl<'a> RefUnwindSafe for Cursor<'a>","synthetic":true,"types":["syn::buffer::Cursor"]},{"text":"impl<T, P> RefUnwindSafe for Punctuated<T, P> where
    P: RefUnwindSafe,
    T: RefUnwindSafe, ","synthetic":true,"types":["syn::punctuated::Punctuated"]},{"text":"impl<'a, T, P> RefUnwindSafe for Pairs<'a, T, P> where
    P: RefUnwindSafe,
    T: RefUnwindSafe, ","synthetic":true,"types":["syn::punctuated::Pairs"]},{"text":"impl<'a, T, P> RefUnwindSafe for PairsMut<'a, T, P> where
    P: RefUnwindSafe,
    T: RefUnwindSafe, ","synthetic":true,"types":["syn::punctuated::PairsMut"]},{"text":"impl<T, P> RefUnwindSafe for IntoPairs<T, P> where
    P: RefUnwindSafe,
    T: RefUnwindSafe, ","synthetic":true,"types":["syn::punctuated::IntoPairs"]},{"text":"impl<T> RefUnwindSafe for IntoIter<T> where
    T: RefUnwindSafe, ","synthetic":true,"types":["syn::punctuated::IntoIter"]},{"text":"impl<'a, T> !RefUnwindSafe for Iter<'a, T>","synthetic":true,"types":["syn::punctuated::Iter"]},{"text":"impl<'a, T> !RefUnwindSafe for IterMut<'a, T>","synthetic":true,"types":["syn::punctuated::IterMut"]},{"text":"impl<T, P> RefUnwindSafe for Pair<T, P> where
    P: RefUnwindSafe,
    T: RefUnwindSafe, ","synthetic":true,"types":["syn::punctuated::Pair"]},{"text":"impl<'a> !RefUnwindSafe for Lookahead1<'a>","synthetic":true,"types":["syn::lookahead::Lookahead1"]},{"text":"impl RefUnwindSafe for Error","synthetic":true,"types":["syn::error::Error"]},{"text":"impl<'a> !RefUnwindSafe for ParseBuffer<'a>","synthetic":true,"types":["syn::parse::ParseBuffer"]},{"text":"impl<'c, 'a> RefUnwindSafe for StepCursor<'c, 'a>","synthetic":true,"types":["syn::parse::StepCursor"]},{"text":"impl RefUnwindSafe for Nothing","synthetic":true,"types":["syn::parse::Nothing"]}]; +implementors["synstructure"] = [{"text":"impl RefUnwindSafe for AddBounds","synthetic":true,"types":["synstructure::AddBounds"]},{"text":"impl RefUnwindSafe for BindStyle","synthetic":true,"types":["synstructure::BindStyle"]},{"text":"impl<'a> RefUnwindSafe for BindingInfo<'a>","synthetic":true,"types":["synstructure::BindingInfo"]},{"text":"impl<'a> RefUnwindSafe for VariantAst<'a>","synthetic":true,"types":["synstructure::VariantAst"]},{"text":"impl<'a> RefUnwindSafe for VariantInfo<'a>","synthetic":true,"types":["synstructure::VariantInfo"]},{"text":"impl<'a> RefUnwindSafe for Structure<'a>","synthetic":true,"types":["synstructure::Structure"]}]; if (window.register_implementors) {window.register_implementors(implementors);} else {window.pending_implementors = implementors;}})() \ No newline at end of file diff --git a/implementors/std/panic/trait.UnwindSafe.js b/implementors/std/panic/trait.UnwindSafe.js index 25a1761..fb4e02d 100644 --- a/implementors/std/panic/trait.UnwindSafe.js +++ b/implementors/std/panic/trait.UnwindSafe.js @@ -1,5 +1,5 @@ (function() {var implementors = {}; -implementors["proc_macro2"] = [{"text":"impl UnwindSafe for IntoIter","synthetic":true,"types":[]},{"text":"impl UnwindSafe for TokenStream","synthetic":true,"types":[]},{"text":"impl UnwindSafe for LexError","synthetic":true,"types":[]},{"text":"impl UnwindSafe for Span","synthetic":true,"types":[]},{"text":"impl UnwindSafe for TokenTree","synthetic":true,"types":[]},{"text":"impl UnwindSafe for Group","synthetic":true,"types":[]},{"text":"impl UnwindSafe for Delimiter","synthetic":true,"types":[]},{"text":"impl UnwindSafe for Punct","synthetic":true,"types":[]},{"text":"impl UnwindSafe for Spacing","synthetic":true,"types":[]},{"text":"impl UnwindSafe for Ident","synthetic":true,"types":[]},{"text":"impl UnwindSafe for Literal","synthetic":true,"types":[]}]; -implementors["syn"] = [{"text":"impl UnwindSafe for Underscore","synthetic":true,"types":[]},{"text":"impl UnwindSafe for Abstract","synthetic":true,"types":[]},{"text":"impl UnwindSafe for As","synthetic":true,"types":[]},{"text":"impl UnwindSafe for Async","synthetic":true,"types":[]},{"text":"impl UnwindSafe for Auto","synthetic":true,"types":[]},{"text":"impl UnwindSafe for Await","synthetic":true,"types":[]},{"text":"impl UnwindSafe for Become","synthetic":true,"types":[]},{"text":"impl UnwindSafe for Box","synthetic":true,"types":[]},{"text":"impl UnwindSafe for Break","synthetic":true,"types":[]},{"text":"impl UnwindSafe for Const","synthetic":true,"types":[]},{"text":"impl UnwindSafe for Continue","synthetic":true,"types":[]},{"text":"impl UnwindSafe for Crate","synthetic":true,"types":[]},{"text":"impl UnwindSafe for Default","synthetic":true,"types":[]},{"text":"impl UnwindSafe for Do","synthetic":true,"types":[]},{"text":"impl UnwindSafe for Dyn","synthetic":true,"types":[]},{"text":"impl UnwindSafe for Else","synthetic":true,"types":[]},{"text":"impl UnwindSafe for Enum","synthetic":true,"types":[]},{"text":"impl UnwindSafe for Extern","synthetic":true,"types":[]},{"text":"impl UnwindSafe for Final","synthetic":true,"types":[]},{"text":"impl UnwindSafe for Fn","synthetic":true,"types":[]},{"text":"impl UnwindSafe for For","synthetic":true,"types":[]},{"text":"impl UnwindSafe for If","synthetic":true,"types":[]},{"text":"impl UnwindSafe for Impl","synthetic":true,"types":[]},{"text":"impl UnwindSafe for In","synthetic":true,"types":[]},{"text":"impl UnwindSafe for Let","synthetic":true,"types":[]},{"text":"impl UnwindSafe for Loop","synthetic":true,"types":[]},{"text":"impl UnwindSafe for Macro","synthetic":true,"types":[]},{"text":"impl UnwindSafe for Match","synthetic":true,"types":[]},{"text":"impl UnwindSafe for Mod","synthetic":true,"types":[]},{"text":"impl UnwindSafe for Move","synthetic":true,"types":[]},{"text":"impl UnwindSafe for Mut","synthetic":true,"types":[]},{"text":"impl UnwindSafe for Override","synthetic":true,"types":[]},{"text":"impl UnwindSafe for Priv","synthetic":true,"types":[]},{"text":"impl UnwindSafe for Pub","synthetic":true,"types":[]},{"text":"impl UnwindSafe for Ref","synthetic":true,"types":[]},{"text":"impl UnwindSafe for Return","synthetic":true,"types":[]},{"text":"impl UnwindSafe for SelfType","synthetic":true,"types":[]},{"text":"impl UnwindSafe for SelfValue","synthetic":true,"types":[]},{"text":"impl UnwindSafe for Static","synthetic":true,"types":[]},{"text":"impl UnwindSafe for Struct","synthetic":true,"types":[]},{"text":"impl UnwindSafe for Super","synthetic":true,"types":[]},{"text":"impl UnwindSafe for Trait","synthetic":true,"types":[]},{"text":"impl UnwindSafe for Try","synthetic":true,"types":[]},{"text":"impl UnwindSafe for Type","synthetic":true,"types":[]},{"text":"impl UnwindSafe for Typeof","synthetic":true,"types":[]},{"text":"impl UnwindSafe for Union","synthetic":true,"types":[]},{"text":"impl UnwindSafe for Unsafe","synthetic":true,"types":[]},{"text":"impl UnwindSafe for Unsized","synthetic":true,"types":[]},{"text":"impl UnwindSafe for Use","synthetic":true,"types":[]},{"text":"impl UnwindSafe for Virtual","synthetic":true,"types":[]},{"text":"impl UnwindSafe for Where","synthetic":true,"types":[]},{"text":"impl UnwindSafe for While","synthetic":true,"types":[]},{"text":"impl UnwindSafe for Yield","synthetic":true,"types":[]},{"text":"impl UnwindSafe for Add","synthetic":true,"types":[]},{"text":"impl UnwindSafe for AddEq","synthetic":true,"types":[]},{"text":"impl UnwindSafe for And","synthetic":true,"types":[]},{"text":"impl UnwindSafe for AndAnd","synthetic":true,"types":[]},{"text":"impl UnwindSafe for AndEq","synthetic":true,"types":[]},{"text":"impl UnwindSafe for At","synthetic":true,"types":[]},{"text":"impl UnwindSafe for Bang","synthetic":true,"types":[]},{"text":"impl UnwindSafe for Caret","synthetic":true,"types":[]},{"text":"impl UnwindSafe for CaretEq","synthetic":true,"types":[]},{"text":"impl UnwindSafe for Colon","synthetic":true,"types":[]},{"text":"impl UnwindSafe for Colon2","synthetic":true,"types":[]},{"text":"impl UnwindSafe for Comma","synthetic":true,"types":[]},{"text":"impl UnwindSafe for Div","synthetic":true,"types":[]},{"text":"impl UnwindSafe for DivEq","synthetic":true,"types":[]},{"text":"impl UnwindSafe for Dollar","synthetic":true,"types":[]},{"text":"impl UnwindSafe for Dot","synthetic":true,"types":[]},{"text":"impl UnwindSafe for Dot2","synthetic":true,"types":[]},{"text":"impl UnwindSafe for Dot3","synthetic":true,"types":[]},{"text":"impl UnwindSafe for DotDotEq","synthetic":true,"types":[]},{"text":"impl UnwindSafe for Eq","synthetic":true,"types":[]},{"text":"impl UnwindSafe for EqEq","synthetic":true,"types":[]},{"text":"impl UnwindSafe for Ge","synthetic":true,"types":[]},{"text":"impl UnwindSafe for Gt","synthetic":true,"types":[]},{"text":"impl UnwindSafe for Le","synthetic":true,"types":[]},{"text":"impl UnwindSafe for Lt","synthetic":true,"types":[]},{"text":"impl UnwindSafe for MulEq","synthetic":true,"types":[]},{"text":"impl UnwindSafe for Ne","synthetic":true,"types":[]},{"text":"impl UnwindSafe for Or","synthetic":true,"types":[]},{"text":"impl UnwindSafe for OrEq","synthetic":true,"types":[]},{"text":"impl UnwindSafe for OrOr","synthetic":true,"types":[]},{"text":"impl UnwindSafe for Pound","synthetic":true,"types":[]},{"text":"impl UnwindSafe for Question","synthetic":true,"types":[]},{"text":"impl UnwindSafe for RArrow","synthetic":true,"types":[]},{"text":"impl UnwindSafe for LArrow","synthetic":true,"types":[]},{"text":"impl UnwindSafe for Rem","synthetic":true,"types":[]},{"text":"impl UnwindSafe for RemEq","synthetic":true,"types":[]},{"text":"impl UnwindSafe for FatArrow","synthetic":true,"types":[]},{"text":"impl UnwindSafe for Semi","synthetic":true,"types":[]},{"text":"impl UnwindSafe for Shl","synthetic":true,"types":[]},{"text":"impl UnwindSafe for ShlEq","synthetic":true,"types":[]},{"text":"impl UnwindSafe for Shr","synthetic":true,"types":[]},{"text":"impl UnwindSafe for ShrEq","synthetic":true,"types":[]},{"text":"impl UnwindSafe for Star","synthetic":true,"types":[]},{"text":"impl UnwindSafe for Sub","synthetic":true,"types":[]},{"text":"impl UnwindSafe for SubEq","synthetic":true,"types":[]},{"text":"impl UnwindSafe for Tilde","synthetic":true,"types":[]},{"text":"impl UnwindSafe for Brace","synthetic":true,"types":[]},{"text":"impl UnwindSafe for Bracket","synthetic":true,"types":[]},{"text":"impl UnwindSafe for Paren","synthetic":true,"types":[]},{"text":"impl UnwindSafe for Group","synthetic":true,"types":[]},{"text":"impl UnwindSafe for Attribute","synthetic":true,"types":[]},{"text":"impl UnwindSafe for AttrStyle","synthetic":true,"types":[]},{"text":"impl UnwindSafe for Meta","synthetic":true,"types":[]},{"text":"impl UnwindSafe for MetaList","synthetic":true,"types":[]},{"text":"impl UnwindSafe for MetaNameValue","synthetic":true,"types":[]},{"text":"impl UnwindSafe for NestedMeta","synthetic":true,"types":[]},{"text":"impl UnwindSafe for Variant","synthetic":true,"types":[]},{"text":"impl UnwindSafe for Fields","synthetic":true,"types":[]},{"text":"impl UnwindSafe for FieldsNamed","synthetic":true,"types":[]},{"text":"impl UnwindSafe for FieldsUnnamed","synthetic":true,"types":[]},{"text":"impl UnwindSafe for Field","synthetic":true,"types":[]},{"text":"impl UnwindSafe for Visibility","synthetic":true,"types":[]},{"text":"impl UnwindSafe for VisPublic","synthetic":true,"types":[]},{"text":"impl UnwindSafe for VisCrate","synthetic":true,"types":[]},{"text":"impl UnwindSafe for VisRestricted","synthetic":true,"types":[]},{"text":"impl UnwindSafe for Expr","synthetic":true,"types":[]},{"text":"impl UnwindSafe for ExprArray","synthetic":true,"types":[]},{"text":"impl UnwindSafe for ExprAssign","synthetic":true,"types":[]},{"text":"impl UnwindSafe for ExprAssignOp","synthetic":true,"types":[]},{"text":"impl UnwindSafe for ExprAsync","synthetic":true,"types":[]},{"text":"impl UnwindSafe for ExprAwait","synthetic":true,"types":[]},{"text":"impl UnwindSafe for ExprBinary","synthetic":true,"types":[]},{"text":"impl UnwindSafe for ExprBlock","synthetic":true,"types":[]},{"text":"impl UnwindSafe for ExprBox","synthetic":true,"types":[]},{"text":"impl UnwindSafe for ExprBreak","synthetic":true,"types":[]},{"text":"impl UnwindSafe for ExprCall","synthetic":true,"types":[]},{"text":"impl UnwindSafe for ExprCast","synthetic":true,"types":[]},{"text":"impl UnwindSafe for ExprClosure","synthetic":true,"types":[]},{"text":"impl UnwindSafe for ExprContinue","synthetic":true,"types":[]},{"text":"impl UnwindSafe for ExprField","synthetic":true,"types":[]},{"text":"impl UnwindSafe for ExprForLoop","synthetic":true,"types":[]},{"text":"impl UnwindSafe for ExprGroup","synthetic":true,"types":[]},{"text":"impl UnwindSafe for ExprIf","synthetic":true,"types":[]},{"text":"impl UnwindSafe for ExprIndex","synthetic":true,"types":[]},{"text":"impl UnwindSafe for ExprLet","synthetic":true,"types":[]},{"text":"impl UnwindSafe for ExprLit","synthetic":true,"types":[]},{"text":"impl UnwindSafe for ExprLoop","synthetic":true,"types":[]},{"text":"impl UnwindSafe for ExprMacro","synthetic":true,"types":[]},{"text":"impl UnwindSafe for ExprMatch","synthetic":true,"types":[]},{"text":"impl UnwindSafe for ExprMethodCall","synthetic":true,"types":[]},{"text":"impl UnwindSafe for ExprParen","synthetic":true,"types":[]},{"text":"impl UnwindSafe for ExprPath","synthetic":true,"types":[]},{"text":"impl UnwindSafe for ExprRange","synthetic":true,"types":[]},{"text":"impl UnwindSafe for ExprReference","synthetic":true,"types":[]},{"text":"impl UnwindSafe for ExprRepeat","synthetic":true,"types":[]},{"text":"impl UnwindSafe for ExprReturn","synthetic":true,"types":[]},{"text":"impl UnwindSafe for ExprStruct","synthetic":true,"types":[]},{"text":"impl UnwindSafe for ExprTry","synthetic":true,"types":[]},{"text":"impl UnwindSafe for ExprTryBlock","synthetic":true,"types":[]},{"text":"impl UnwindSafe for ExprTuple","synthetic":true,"types":[]},{"text":"impl UnwindSafe for ExprType","synthetic":true,"types":[]},{"text":"impl UnwindSafe for ExprUnary","synthetic":true,"types":[]},{"text":"impl UnwindSafe for ExprUnsafe","synthetic":true,"types":[]},{"text":"impl UnwindSafe for ExprWhile","synthetic":true,"types":[]},{"text":"impl UnwindSafe for ExprYield","synthetic":true,"types":[]},{"text":"impl UnwindSafe for Member","synthetic":true,"types":[]},{"text":"impl UnwindSafe for Index","synthetic":true,"types":[]},{"text":"impl UnwindSafe for Generics","synthetic":true,"types":[]},{"text":"impl UnwindSafe for GenericParam","synthetic":true,"types":[]},{"text":"impl UnwindSafe for TypeParam","synthetic":true,"types":[]},{"text":"impl UnwindSafe for LifetimeDef","synthetic":true,"types":[]},{"text":"impl UnwindSafe for ConstParam","synthetic":true,"types":[]},{"text":"impl<'a> UnwindSafe for ImplGenerics<'a>","synthetic":true,"types":[]},{"text":"impl<'a> UnwindSafe for TypeGenerics<'a>","synthetic":true,"types":[]},{"text":"impl<'a> UnwindSafe for Turbofish<'a>","synthetic":true,"types":[]},{"text":"impl UnwindSafe for BoundLifetimes","synthetic":true,"types":[]},{"text":"impl UnwindSafe for TypeParamBound","synthetic":true,"types":[]},{"text":"impl UnwindSafe for TraitBound","synthetic":true,"types":[]},{"text":"impl UnwindSafe for TraitBoundModifier","synthetic":true,"types":[]},{"text":"impl UnwindSafe for WhereClause","synthetic":true,"types":[]},{"text":"impl UnwindSafe for WherePredicate","synthetic":true,"types":[]},{"text":"impl UnwindSafe for PredicateType","synthetic":true,"types":[]},{"text":"impl UnwindSafe for PredicateLifetime","synthetic":true,"types":[]},{"text":"impl UnwindSafe for PredicateEq","synthetic":true,"types":[]},{"text":"impl UnwindSafe for Lifetime","synthetic":true,"types":[]},{"text":"impl UnwindSafe for Lit","synthetic":true,"types":[]},{"text":"impl UnwindSafe for LitStr","synthetic":true,"types":[]},{"text":"impl UnwindSafe for LitByteStr","synthetic":true,"types":[]},{"text":"impl UnwindSafe for LitByte","synthetic":true,"types":[]},{"text":"impl UnwindSafe for LitChar","synthetic":true,"types":[]},{"text":"impl UnwindSafe for LitInt","synthetic":true,"types":[]},{"text":"impl UnwindSafe for LitFloat","synthetic":true,"types":[]},{"text":"impl UnwindSafe for LitBool","synthetic":true,"types":[]},{"text":"impl UnwindSafe for StrStyle","synthetic":true,"types":[]},{"text":"impl UnwindSafe for Macro","synthetic":true,"types":[]},{"text":"impl UnwindSafe for MacroDelimiter","synthetic":true,"types":[]},{"text":"impl UnwindSafe for DeriveInput","synthetic":true,"types":[]},{"text":"impl UnwindSafe for Data","synthetic":true,"types":[]},{"text":"impl UnwindSafe for DataStruct","synthetic":true,"types":[]},{"text":"impl UnwindSafe for DataEnum","synthetic":true,"types":[]},{"text":"impl UnwindSafe for DataUnion","synthetic":true,"types":[]},{"text":"impl UnwindSafe for BinOp","synthetic":true,"types":[]},{"text":"impl UnwindSafe for UnOp","synthetic":true,"types":[]},{"text":"impl UnwindSafe for Type","synthetic":true,"types":[]},{"text":"impl UnwindSafe for TypeArray","synthetic":true,"types":[]},{"text":"impl UnwindSafe for TypeBareFn","synthetic":true,"types":[]},{"text":"impl UnwindSafe for TypeGroup","synthetic":true,"types":[]},{"text":"impl UnwindSafe for TypeImplTrait","synthetic":true,"types":[]},{"text":"impl UnwindSafe for TypeInfer","synthetic":true,"types":[]},{"text":"impl UnwindSafe for TypeMacro","synthetic":true,"types":[]},{"text":"impl UnwindSafe for TypeNever","synthetic":true,"types":[]},{"text":"impl UnwindSafe for TypeParen","synthetic":true,"types":[]},{"text":"impl UnwindSafe for TypePath","synthetic":true,"types":[]},{"text":"impl UnwindSafe for TypePtr","synthetic":true,"types":[]},{"text":"impl UnwindSafe for TypeReference","synthetic":true,"types":[]},{"text":"impl UnwindSafe for TypeSlice","synthetic":true,"types":[]},{"text":"impl UnwindSafe for TypeTraitObject","synthetic":true,"types":[]},{"text":"impl UnwindSafe for TypeTuple","synthetic":true,"types":[]},{"text":"impl UnwindSafe for Abi","synthetic":true,"types":[]},{"text":"impl UnwindSafe for BareFnArg","synthetic":true,"types":[]},{"text":"impl UnwindSafe for Variadic","synthetic":true,"types":[]},{"text":"impl UnwindSafe for ReturnType","synthetic":true,"types":[]},{"text":"impl UnwindSafe for Path","synthetic":true,"types":[]},{"text":"impl UnwindSafe for PathSegment","synthetic":true,"types":[]},{"text":"impl UnwindSafe for PathArguments","synthetic":true,"types":[]},{"text":"impl UnwindSafe for GenericArgument","synthetic":true,"types":[]},{"text":"impl UnwindSafe for AngleBracketedGenericArguments","synthetic":true,"types":[]},{"text":"impl UnwindSafe for Binding","synthetic":true,"types":[]},{"text":"impl UnwindSafe for Constraint","synthetic":true,"types":[]},{"text":"impl UnwindSafe for ParenthesizedGenericArguments","synthetic":true,"types":[]},{"text":"impl UnwindSafe for QSelf","synthetic":true,"types":[]},{"text":"impl UnwindSafe for TokenBuffer","synthetic":true,"types":[]},{"text":"impl<'a> UnwindSafe for Cursor<'a>","synthetic":true,"types":[]},{"text":"impl<T, P> UnwindSafe for Punctuated<T, P> where
    P: UnwindSafe,
    T: UnwindSafe, ","synthetic":true,"types":[]},{"text":"impl<'a, T, P> UnwindSafe for Pairs<'a, T, P> where
    P: RefUnwindSafe,
    T: RefUnwindSafe, ","synthetic":true,"types":[]},{"text":"impl<'a, T, P> !UnwindSafe for PairsMut<'a, T, P>","synthetic":true,"types":[]},{"text":"impl<T, P> UnwindSafe for IntoPairs<T, P> where
    P: RefUnwindSafe + UnwindSafe,
    T: RefUnwindSafe + UnwindSafe, ","synthetic":true,"types":[]},{"text":"impl<T> UnwindSafe for IntoIter<T> where
    T: RefUnwindSafe + UnwindSafe, ","synthetic":true,"types":[]},{"text":"impl<'a, T> !UnwindSafe for Iter<'a, T>","synthetic":true,"types":[]},{"text":"impl<'a, T> !UnwindSafe for IterMut<'a, T>","synthetic":true,"types":[]},{"text":"impl<T, P> UnwindSafe for Pair<T, P> where
    P: UnwindSafe,
    T: UnwindSafe, ","synthetic":true,"types":[]},{"text":"impl<'a> UnwindSafe for Lookahead1<'a>","synthetic":true,"types":[]},{"text":"impl UnwindSafe for Error","synthetic":true,"types":[]},{"text":"impl<'a> !UnwindSafe for ParseBuffer<'a>","synthetic":true,"types":[]},{"text":"impl<'c, 'a> UnwindSafe for StepCursor<'c, 'a>","synthetic":true,"types":[]},{"text":"impl UnwindSafe for Nothing","synthetic":true,"types":[]}]; -implementors["synstructure"] = [{"text":"impl UnwindSafe for AddBounds","synthetic":true,"types":[]},{"text":"impl UnwindSafe for BindStyle","synthetic":true,"types":[]},{"text":"impl<'a> UnwindSafe for BindingInfo<'a>","synthetic":true,"types":[]},{"text":"impl<'a> UnwindSafe for VariantAst<'a>","synthetic":true,"types":[]},{"text":"impl<'a> UnwindSafe for VariantInfo<'a>","synthetic":true,"types":[]},{"text":"impl<'a> UnwindSafe for Structure<'a>","synthetic":true,"types":[]}]; +implementors["proc_macro2"] = [{"text":"impl UnwindSafe for IntoIter","synthetic":true,"types":["proc_macro2::token_stream::IntoIter"]},{"text":"impl UnwindSafe for TokenStream","synthetic":true,"types":["proc_macro2::TokenStream"]},{"text":"impl UnwindSafe for LexError","synthetic":true,"types":["proc_macro2::LexError"]},{"text":"impl UnwindSafe for Span","synthetic":true,"types":["proc_macro2::Span"]},{"text":"impl UnwindSafe for TokenTree","synthetic":true,"types":["proc_macro2::TokenTree"]},{"text":"impl UnwindSafe for Group","synthetic":true,"types":["proc_macro2::Group"]},{"text":"impl UnwindSafe for Delimiter","synthetic":true,"types":["proc_macro2::Delimiter"]},{"text":"impl UnwindSafe for Punct","synthetic":true,"types":["proc_macro2::Punct"]},{"text":"impl UnwindSafe for Spacing","synthetic":true,"types":["proc_macro2::Spacing"]},{"text":"impl UnwindSafe for Ident","synthetic":true,"types":["proc_macro2::Ident"]},{"text":"impl UnwindSafe for Literal","synthetic":true,"types":["proc_macro2::Literal"]}]; +implementors["syn"] = [{"text":"impl UnwindSafe for Underscore","synthetic":true,"types":["syn::token::Underscore"]},{"text":"impl UnwindSafe for Abstract","synthetic":true,"types":["syn::token::Abstract"]},{"text":"impl UnwindSafe for As","synthetic":true,"types":["syn::token::As"]},{"text":"impl UnwindSafe for Async","synthetic":true,"types":["syn::token::Async"]},{"text":"impl UnwindSafe for Auto","synthetic":true,"types":["syn::token::Auto"]},{"text":"impl UnwindSafe for Await","synthetic":true,"types":["syn::token::Await"]},{"text":"impl UnwindSafe for Become","synthetic":true,"types":["syn::token::Become"]},{"text":"impl UnwindSafe for Box","synthetic":true,"types":["syn::token::Box"]},{"text":"impl UnwindSafe for Break","synthetic":true,"types":["syn::token::Break"]},{"text":"impl UnwindSafe for Const","synthetic":true,"types":["syn::token::Const"]},{"text":"impl UnwindSafe for Continue","synthetic":true,"types":["syn::token::Continue"]},{"text":"impl UnwindSafe for Crate","synthetic":true,"types":["syn::token::Crate"]},{"text":"impl UnwindSafe for Default","synthetic":true,"types":["syn::token::Default"]},{"text":"impl UnwindSafe for Do","synthetic":true,"types":["syn::token::Do"]},{"text":"impl UnwindSafe for Dyn","synthetic":true,"types":["syn::token::Dyn"]},{"text":"impl UnwindSafe for Else","synthetic":true,"types":["syn::token::Else"]},{"text":"impl UnwindSafe for Enum","synthetic":true,"types":["syn::token::Enum"]},{"text":"impl UnwindSafe for Extern","synthetic":true,"types":["syn::token::Extern"]},{"text":"impl UnwindSafe for Final","synthetic":true,"types":["syn::token::Final"]},{"text":"impl UnwindSafe for Fn","synthetic":true,"types":["syn::token::Fn"]},{"text":"impl UnwindSafe for For","synthetic":true,"types":["syn::token::For"]},{"text":"impl UnwindSafe for If","synthetic":true,"types":["syn::token::If"]},{"text":"impl UnwindSafe for Impl","synthetic":true,"types":["syn::token::Impl"]},{"text":"impl UnwindSafe for In","synthetic":true,"types":["syn::token::In"]},{"text":"impl UnwindSafe for Let","synthetic":true,"types":["syn::token::Let"]},{"text":"impl UnwindSafe for Loop","synthetic":true,"types":["syn::token::Loop"]},{"text":"impl UnwindSafe for Macro","synthetic":true,"types":["syn::token::Macro"]},{"text":"impl UnwindSafe for Match","synthetic":true,"types":["syn::token::Match"]},{"text":"impl UnwindSafe for Mod","synthetic":true,"types":["syn::token::Mod"]},{"text":"impl UnwindSafe for Move","synthetic":true,"types":["syn::token::Move"]},{"text":"impl UnwindSafe for Mut","synthetic":true,"types":["syn::token::Mut"]},{"text":"impl UnwindSafe for Override","synthetic":true,"types":["syn::token::Override"]},{"text":"impl UnwindSafe for Priv","synthetic":true,"types":["syn::token::Priv"]},{"text":"impl UnwindSafe for Pub","synthetic":true,"types":["syn::token::Pub"]},{"text":"impl UnwindSafe for Ref","synthetic":true,"types":["syn::token::Ref"]},{"text":"impl UnwindSafe for Return","synthetic":true,"types":["syn::token::Return"]},{"text":"impl UnwindSafe for SelfType","synthetic":true,"types":["syn::token::SelfType"]},{"text":"impl UnwindSafe for SelfValue","synthetic":true,"types":["syn::token::SelfValue"]},{"text":"impl UnwindSafe for Static","synthetic":true,"types":["syn::token::Static"]},{"text":"impl UnwindSafe for Struct","synthetic":true,"types":["syn::token::Struct"]},{"text":"impl UnwindSafe for Super","synthetic":true,"types":["syn::token::Super"]},{"text":"impl UnwindSafe for Trait","synthetic":true,"types":["syn::token::Trait"]},{"text":"impl UnwindSafe for Try","synthetic":true,"types":["syn::token::Try"]},{"text":"impl UnwindSafe for Type","synthetic":true,"types":["syn::token::Type"]},{"text":"impl UnwindSafe for Typeof","synthetic":true,"types":["syn::token::Typeof"]},{"text":"impl UnwindSafe for Union","synthetic":true,"types":["syn::token::Union"]},{"text":"impl UnwindSafe for Unsafe","synthetic":true,"types":["syn::token::Unsafe"]},{"text":"impl UnwindSafe for Unsized","synthetic":true,"types":["syn::token::Unsized"]},{"text":"impl UnwindSafe for Use","synthetic":true,"types":["syn::token::Use"]},{"text":"impl UnwindSafe for Virtual","synthetic":true,"types":["syn::token::Virtual"]},{"text":"impl UnwindSafe for Where","synthetic":true,"types":["syn::token::Where"]},{"text":"impl UnwindSafe for While","synthetic":true,"types":["syn::token::While"]},{"text":"impl UnwindSafe for Yield","synthetic":true,"types":["syn::token::Yield"]},{"text":"impl UnwindSafe for Add","synthetic":true,"types":["syn::token::Add"]},{"text":"impl UnwindSafe for AddEq","synthetic":true,"types":["syn::token::AddEq"]},{"text":"impl UnwindSafe for And","synthetic":true,"types":["syn::token::And"]},{"text":"impl UnwindSafe for AndAnd","synthetic":true,"types":["syn::token::AndAnd"]},{"text":"impl UnwindSafe for AndEq","synthetic":true,"types":["syn::token::AndEq"]},{"text":"impl UnwindSafe for At","synthetic":true,"types":["syn::token::At"]},{"text":"impl UnwindSafe for Bang","synthetic":true,"types":["syn::token::Bang"]},{"text":"impl UnwindSafe for Caret","synthetic":true,"types":["syn::token::Caret"]},{"text":"impl UnwindSafe for CaretEq","synthetic":true,"types":["syn::token::CaretEq"]},{"text":"impl UnwindSafe for Colon","synthetic":true,"types":["syn::token::Colon"]},{"text":"impl UnwindSafe for Colon2","synthetic":true,"types":["syn::token::Colon2"]},{"text":"impl UnwindSafe for Comma","synthetic":true,"types":["syn::token::Comma"]},{"text":"impl UnwindSafe for Div","synthetic":true,"types":["syn::token::Div"]},{"text":"impl UnwindSafe for DivEq","synthetic":true,"types":["syn::token::DivEq"]},{"text":"impl UnwindSafe for Dollar","synthetic":true,"types":["syn::token::Dollar"]},{"text":"impl UnwindSafe for Dot","synthetic":true,"types":["syn::token::Dot"]},{"text":"impl UnwindSafe for Dot2","synthetic":true,"types":["syn::token::Dot2"]},{"text":"impl UnwindSafe for Dot3","synthetic":true,"types":["syn::token::Dot3"]},{"text":"impl UnwindSafe for DotDotEq","synthetic":true,"types":["syn::token::DotDotEq"]},{"text":"impl UnwindSafe for Eq","synthetic":true,"types":["syn::token::Eq"]},{"text":"impl UnwindSafe for EqEq","synthetic":true,"types":["syn::token::EqEq"]},{"text":"impl UnwindSafe for Ge","synthetic":true,"types":["syn::token::Ge"]},{"text":"impl UnwindSafe for Gt","synthetic":true,"types":["syn::token::Gt"]},{"text":"impl UnwindSafe for Le","synthetic":true,"types":["syn::token::Le"]},{"text":"impl UnwindSafe for Lt","synthetic":true,"types":["syn::token::Lt"]},{"text":"impl UnwindSafe for MulEq","synthetic":true,"types":["syn::token::MulEq"]},{"text":"impl UnwindSafe for Ne","synthetic":true,"types":["syn::token::Ne"]},{"text":"impl UnwindSafe for Or","synthetic":true,"types":["syn::token::Or"]},{"text":"impl UnwindSafe for OrEq","synthetic":true,"types":["syn::token::OrEq"]},{"text":"impl UnwindSafe for OrOr","synthetic":true,"types":["syn::token::OrOr"]},{"text":"impl UnwindSafe for Pound","synthetic":true,"types":["syn::token::Pound"]},{"text":"impl UnwindSafe for Question","synthetic":true,"types":["syn::token::Question"]},{"text":"impl UnwindSafe for RArrow","synthetic":true,"types":["syn::token::RArrow"]},{"text":"impl UnwindSafe for LArrow","synthetic":true,"types":["syn::token::LArrow"]},{"text":"impl UnwindSafe for Rem","synthetic":true,"types":["syn::token::Rem"]},{"text":"impl UnwindSafe for RemEq","synthetic":true,"types":["syn::token::RemEq"]},{"text":"impl UnwindSafe for FatArrow","synthetic":true,"types":["syn::token::FatArrow"]},{"text":"impl UnwindSafe for Semi","synthetic":true,"types":["syn::token::Semi"]},{"text":"impl UnwindSafe for Shl","synthetic":true,"types":["syn::token::Shl"]},{"text":"impl UnwindSafe for ShlEq","synthetic":true,"types":["syn::token::ShlEq"]},{"text":"impl UnwindSafe for Shr","synthetic":true,"types":["syn::token::Shr"]},{"text":"impl UnwindSafe for ShrEq","synthetic":true,"types":["syn::token::ShrEq"]},{"text":"impl UnwindSafe for Star","synthetic":true,"types":["syn::token::Star"]},{"text":"impl UnwindSafe for Sub","synthetic":true,"types":["syn::token::Sub"]},{"text":"impl UnwindSafe for SubEq","synthetic":true,"types":["syn::token::SubEq"]},{"text":"impl UnwindSafe for Tilde","synthetic":true,"types":["syn::token::Tilde"]},{"text":"impl UnwindSafe for Brace","synthetic":true,"types":["syn::token::Brace"]},{"text":"impl UnwindSafe for Bracket","synthetic":true,"types":["syn::token::Bracket"]},{"text":"impl UnwindSafe for Paren","synthetic":true,"types":["syn::token::Paren"]},{"text":"impl UnwindSafe for Group","synthetic":true,"types":["syn::token::Group"]},{"text":"impl UnwindSafe for Attribute","synthetic":true,"types":["syn::attr::Attribute"]},{"text":"impl UnwindSafe for AttrStyle","synthetic":true,"types":["syn::attr::AttrStyle"]},{"text":"impl UnwindSafe for Meta","synthetic":true,"types":["syn::attr::Meta"]},{"text":"impl UnwindSafe for MetaList","synthetic":true,"types":["syn::attr::MetaList"]},{"text":"impl UnwindSafe for MetaNameValue","synthetic":true,"types":["syn::attr::MetaNameValue"]},{"text":"impl UnwindSafe for NestedMeta","synthetic":true,"types":["syn::attr::NestedMeta"]},{"text":"impl UnwindSafe for Variant","synthetic":true,"types":["syn::data::Variant"]},{"text":"impl UnwindSafe for Fields","synthetic":true,"types":["syn::data::Fields"]},{"text":"impl UnwindSafe for FieldsNamed","synthetic":true,"types":["syn::data::FieldsNamed"]},{"text":"impl UnwindSafe for FieldsUnnamed","synthetic":true,"types":["syn::data::FieldsUnnamed"]},{"text":"impl UnwindSafe for Field","synthetic":true,"types":["syn::data::Field"]},{"text":"impl UnwindSafe for Visibility","synthetic":true,"types":["syn::data::Visibility"]},{"text":"impl UnwindSafe for VisPublic","synthetic":true,"types":["syn::data::VisPublic"]},{"text":"impl UnwindSafe for VisCrate","synthetic":true,"types":["syn::data::VisCrate"]},{"text":"impl UnwindSafe for VisRestricted","synthetic":true,"types":["syn::data::VisRestricted"]},{"text":"impl UnwindSafe for Expr","synthetic":true,"types":["syn::expr::Expr"]},{"text":"impl UnwindSafe for ExprArray","synthetic":true,"types":["syn::expr::ExprArray"]},{"text":"impl UnwindSafe for ExprAssign","synthetic":true,"types":["syn::expr::ExprAssign"]},{"text":"impl UnwindSafe for ExprAssignOp","synthetic":true,"types":["syn::expr::ExprAssignOp"]},{"text":"impl UnwindSafe for ExprAsync","synthetic":true,"types":["syn::expr::ExprAsync"]},{"text":"impl UnwindSafe for ExprAwait","synthetic":true,"types":["syn::expr::ExprAwait"]},{"text":"impl UnwindSafe for ExprBinary","synthetic":true,"types":["syn::expr::ExprBinary"]},{"text":"impl UnwindSafe for ExprBlock","synthetic":true,"types":["syn::expr::ExprBlock"]},{"text":"impl UnwindSafe for ExprBox","synthetic":true,"types":["syn::expr::ExprBox"]},{"text":"impl UnwindSafe for ExprBreak","synthetic":true,"types":["syn::expr::ExprBreak"]},{"text":"impl UnwindSafe for ExprCall","synthetic":true,"types":["syn::expr::ExprCall"]},{"text":"impl UnwindSafe for ExprCast","synthetic":true,"types":["syn::expr::ExprCast"]},{"text":"impl UnwindSafe for ExprClosure","synthetic":true,"types":["syn::expr::ExprClosure"]},{"text":"impl UnwindSafe for ExprContinue","synthetic":true,"types":["syn::expr::ExprContinue"]},{"text":"impl UnwindSafe for ExprField","synthetic":true,"types":["syn::expr::ExprField"]},{"text":"impl UnwindSafe for ExprForLoop","synthetic":true,"types":["syn::expr::ExprForLoop"]},{"text":"impl UnwindSafe for ExprGroup","synthetic":true,"types":["syn::expr::ExprGroup"]},{"text":"impl UnwindSafe for ExprIf","synthetic":true,"types":["syn::expr::ExprIf"]},{"text":"impl UnwindSafe for ExprIndex","synthetic":true,"types":["syn::expr::ExprIndex"]},{"text":"impl UnwindSafe for ExprLet","synthetic":true,"types":["syn::expr::ExprLet"]},{"text":"impl UnwindSafe for ExprLit","synthetic":true,"types":["syn::expr::ExprLit"]},{"text":"impl UnwindSafe for ExprLoop","synthetic":true,"types":["syn::expr::ExprLoop"]},{"text":"impl UnwindSafe for ExprMacro","synthetic":true,"types":["syn::expr::ExprMacro"]},{"text":"impl UnwindSafe for ExprMatch","synthetic":true,"types":["syn::expr::ExprMatch"]},{"text":"impl UnwindSafe for ExprMethodCall","synthetic":true,"types":["syn::expr::ExprMethodCall"]},{"text":"impl UnwindSafe for ExprParen","synthetic":true,"types":["syn::expr::ExprParen"]},{"text":"impl UnwindSafe for ExprPath","synthetic":true,"types":["syn::expr::ExprPath"]},{"text":"impl UnwindSafe for ExprRange","synthetic":true,"types":["syn::expr::ExprRange"]},{"text":"impl UnwindSafe for ExprReference","synthetic":true,"types":["syn::expr::ExprReference"]},{"text":"impl UnwindSafe for ExprRepeat","synthetic":true,"types":["syn::expr::ExprRepeat"]},{"text":"impl UnwindSafe for ExprReturn","synthetic":true,"types":["syn::expr::ExprReturn"]},{"text":"impl UnwindSafe for ExprStruct","synthetic":true,"types":["syn::expr::ExprStruct"]},{"text":"impl UnwindSafe for ExprTry","synthetic":true,"types":["syn::expr::ExprTry"]},{"text":"impl UnwindSafe for ExprTryBlock","synthetic":true,"types":["syn::expr::ExprTryBlock"]},{"text":"impl UnwindSafe for ExprTuple","synthetic":true,"types":["syn::expr::ExprTuple"]},{"text":"impl UnwindSafe for ExprType","synthetic":true,"types":["syn::expr::ExprType"]},{"text":"impl UnwindSafe for ExprUnary","synthetic":true,"types":["syn::expr::ExprUnary"]},{"text":"impl UnwindSafe for ExprUnsafe","synthetic":true,"types":["syn::expr::ExprUnsafe"]},{"text":"impl UnwindSafe for ExprWhile","synthetic":true,"types":["syn::expr::ExprWhile"]},{"text":"impl UnwindSafe for ExprYield","synthetic":true,"types":["syn::expr::ExprYield"]},{"text":"impl UnwindSafe for Member","synthetic":true,"types":["syn::expr::Member"]},{"text":"impl UnwindSafe for Index","synthetic":true,"types":["syn::expr::Index"]},{"text":"impl UnwindSafe for Generics","synthetic":true,"types":["syn::generics::Generics"]},{"text":"impl UnwindSafe for GenericParam","synthetic":true,"types":["syn::generics::GenericParam"]},{"text":"impl UnwindSafe for TypeParam","synthetic":true,"types":["syn::generics::TypeParam"]},{"text":"impl UnwindSafe for LifetimeDef","synthetic":true,"types":["syn::generics::LifetimeDef"]},{"text":"impl UnwindSafe for ConstParam","synthetic":true,"types":["syn::generics::ConstParam"]},{"text":"impl<'a> UnwindSafe for ImplGenerics<'a>","synthetic":true,"types":["syn::generics::ImplGenerics"]},{"text":"impl<'a> UnwindSafe for TypeGenerics<'a>","synthetic":true,"types":["syn::generics::TypeGenerics"]},{"text":"impl<'a> UnwindSafe for Turbofish<'a>","synthetic":true,"types":["syn::generics::Turbofish"]},{"text":"impl UnwindSafe for BoundLifetimes","synthetic":true,"types":["syn::generics::BoundLifetimes"]},{"text":"impl UnwindSafe for TypeParamBound","synthetic":true,"types":["syn::generics::TypeParamBound"]},{"text":"impl UnwindSafe for TraitBound","synthetic":true,"types":["syn::generics::TraitBound"]},{"text":"impl UnwindSafe for TraitBoundModifier","synthetic":true,"types":["syn::generics::TraitBoundModifier"]},{"text":"impl UnwindSafe for WhereClause","synthetic":true,"types":["syn::generics::WhereClause"]},{"text":"impl UnwindSafe for WherePredicate","synthetic":true,"types":["syn::generics::WherePredicate"]},{"text":"impl UnwindSafe for PredicateType","synthetic":true,"types":["syn::generics::PredicateType"]},{"text":"impl UnwindSafe for PredicateLifetime","synthetic":true,"types":["syn::generics::PredicateLifetime"]},{"text":"impl UnwindSafe for PredicateEq","synthetic":true,"types":["syn::generics::PredicateEq"]},{"text":"impl UnwindSafe for Lifetime","synthetic":true,"types":["syn::lifetime::Lifetime"]},{"text":"impl UnwindSafe for Lit","synthetic":true,"types":["syn::lit::Lit"]},{"text":"impl UnwindSafe for LitStr","synthetic":true,"types":["syn::lit::LitStr"]},{"text":"impl UnwindSafe for LitByteStr","synthetic":true,"types":["syn::lit::LitByteStr"]},{"text":"impl UnwindSafe for LitByte","synthetic":true,"types":["syn::lit::LitByte"]},{"text":"impl UnwindSafe for LitChar","synthetic":true,"types":["syn::lit::LitChar"]},{"text":"impl UnwindSafe for LitInt","synthetic":true,"types":["syn::lit::LitInt"]},{"text":"impl UnwindSafe for LitFloat","synthetic":true,"types":["syn::lit::LitFloat"]},{"text":"impl UnwindSafe for LitBool","synthetic":true,"types":["syn::lit::LitBool"]},{"text":"impl UnwindSafe for StrStyle","synthetic":true,"types":["syn::lit::StrStyle"]},{"text":"impl UnwindSafe for Macro","synthetic":true,"types":["syn::mac::Macro"]},{"text":"impl UnwindSafe for MacroDelimiter","synthetic":true,"types":["syn::mac::MacroDelimiter"]},{"text":"impl UnwindSafe for DeriveInput","synthetic":true,"types":["syn::derive::DeriveInput"]},{"text":"impl UnwindSafe for Data","synthetic":true,"types":["syn::derive::Data"]},{"text":"impl UnwindSafe for DataStruct","synthetic":true,"types":["syn::derive::DataStruct"]},{"text":"impl UnwindSafe for DataEnum","synthetic":true,"types":["syn::derive::DataEnum"]},{"text":"impl UnwindSafe for DataUnion","synthetic":true,"types":["syn::derive::DataUnion"]},{"text":"impl UnwindSafe for BinOp","synthetic":true,"types":["syn::op::BinOp"]},{"text":"impl UnwindSafe for UnOp","synthetic":true,"types":["syn::op::UnOp"]},{"text":"impl UnwindSafe for Type","synthetic":true,"types":["syn::ty::Type"]},{"text":"impl UnwindSafe for TypeArray","synthetic":true,"types":["syn::ty::TypeArray"]},{"text":"impl UnwindSafe for TypeBareFn","synthetic":true,"types":["syn::ty::TypeBareFn"]},{"text":"impl UnwindSafe for TypeGroup","synthetic":true,"types":["syn::ty::TypeGroup"]},{"text":"impl UnwindSafe for TypeImplTrait","synthetic":true,"types":["syn::ty::TypeImplTrait"]},{"text":"impl UnwindSafe for TypeInfer","synthetic":true,"types":["syn::ty::TypeInfer"]},{"text":"impl UnwindSafe for TypeMacro","synthetic":true,"types":["syn::ty::TypeMacro"]},{"text":"impl UnwindSafe for TypeNever","synthetic":true,"types":["syn::ty::TypeNever"]},{"text":"impl UnwindSafe for TypeParen","synthetic":true,"types":["syn::ty::TypeParen"]},{"text":"impl UnwindSafe for TypePath","synthetic":true,"types":["syn::ty::TypePath"]},{"text":"impl UnwindSafe for TypePtr","synthetic":true,"types":["syn::ty::TypePtr"]},{"text":"impl UnwindSafe for TypeReference","synthetic":true,"types":["syn::ty::TypeReference"]},{"text":"impl UnwindSafe for TypeSlice","synthetic":true,"types":["syn::ty::TypeSlice"]},{"text":"impl UnwindSafe for TypeTraitObject","synthetic":true,"types":["syn::ty::TypeTraitObject"]},{"text":"impl UnwindSafe for TypeTuple","synthetic":true,"types":["syn::ty::TypeTuple"]},{"text":"impl UnwindSafe for Abi","synthetic":true,"types":["syn::ty::Abi"]},{"text":"impl UnwindSafe for BareFnArg","synthetic":true,"types":["syn::ty::BareFnArg"]},{"text":"impl UnwindSafe for Variadic","synthetic":true,"types":["syn::ty::Variadic"]},{"text":"impl UnwindSafe for ReturnType","synthetic":true,"types":["syn::ty::ReturnType"]},{"text":"impl UnwindSafe for Path","synthetic":true,"types":["syn::path::Path"]},{"text":"impl UnwindSafe for PathSegment","synthetic":true,"types":["syn::path::PathSegment"]},{"text":"impl UnwindSafe for PathArguments","synthetic":true,"types":["syn::path::PathArguments"]},{"text":"impl UnwindSafe for GenericArgument","synthetic":true,"types":["syn::path::GenericArgument"]},{"text":"impl UnwindSafe for AngleBracketedGenericArguments","synthetic":true,"types":["syn::path::AngleBracketedGenericArguments"]},{"text":"impl UnwindSafe for Binding","synthetic":true,"types":["syn::path::Binding"]},{"text":"impl UnwindSafe for Constraint","synthetic":true,"types":["syn::path::Constraint"]},{"text":"impl UnwindSafe for ParenthesizedGenericArguments","synthetic":true,"types":["syn::path::ParenthesizedGenericArguments"]},{"text":"impl UnwindSafe for QSelf","synthetic":true,"types":["syn::path::QSelf"]},{"text":"impl UnwindSafe for TokenBuffer","synthetic":true,"types":["syn::buffer::TokenBuffer"]},{"text":"impl<'a> UnwindSafe for Cursor<'a>","synthetic":true,"types":["syn::buffer::Cursor"]},{"text":"impl<T, P> UnwindSafe for Punctuated<T, P> where
    P: UnwindSafe,
    T: UnwindSafe, ","synthetic":true,"types":["syn::punctuated::Punctuated"]},{"text":"impl<'a, T, P> UnwindSafe for Pairs<'a, T, P> where
    P: RefUnwindSafe,
    T: RefUnwindSafe, ","synthetic":true,"types":["syn::punctuated::Pairs"]},{"text":"impl<'a, T, P> !UnwindSafe for PairsMut<'a, T, P>","synthetic":true,"types":["syn::punctuated::PairsMut"]},{"text":"impl<T, P> UnwindSafe for IntoPairs<T, P> where
    P: RefUnwindSafe + UnwindSafe,
    T: RefUnwindSafe + UnwindSafe, ","synthetic":true,"types":["syn::punctuated::IntoPairs"]},{"text":"impl<T> UnwindSafe for IntoIter<T> where
    T: RefUnwindSafe + UnwindSafe, ","synthetic":true,"types":["syn::punctuated::IntoIter"]},{"text":"impl<'a, T> !UnwindSafe for Iter<'a, T>","synthetic":true,"types":["syn::punctuated::Iter"]},{"text":"impl<'a, T> !UnwindSafe for IterMut<'a, T>","synthetic":true,"types":["syn::punctuated::IterMut"]},{"text":"impl<T, P> UnwindSafe for Pair<T, P> where
    P: UnwindSafe,
    T: UnwindSafe, ","synthetic":true,"types":["syn::punctuated::Pair"]},{"text":"impl<'a> UnwindSafe for Lookahead1<'a>","synthetic":true,"types":["syn::lookahead::Lookahead1"]},{"text":"impl UnwindSafe for Error","synthetic":true,"types":["syn::error::Error"]},{"text":"impl<'a> !UnwindSafe for ParseBuffer<'a>","synthetic":true,"types":["syn::parse::ParseBuffer"]},{"text":"impl<'c, 'a> UnwindSafe for StepCursor<'c, 'a>","synthetic":true,"types":["syn::parse::StepCursor"]},{"text":"impl UnwindSafe for Nothing","synthetic":true,"types":["syn::parse::Nothing"]}]; +implementors["synstructure"] = [{"text":"impl UnwindSafe for AddBounds","synthetic":true,"types":["synstructure::AddBounds"]},{"text":"impl UnwindSafe for BindStyle","synthetic":true,"types":["synstructure::BindStyle"]},{"text":"impl<'a> UnwindSafe for BindingInfo<'a>","synthetic":true,"types":["synstructure::BindingInfo"]},{"text":"impl<'a> UnwindSafe for VariantAst<'a>","synthetic":true,"types":["synstructure::VariantAst"]},{"text":"impl<'a> UnwindSafe for VariantInfo<'a>","synthetic":true,"types":["synstructure::VariantInfo"]},{"text":"impl<'a> UnwindSafe for Structure<'a>","synthetic":true,"types":["synstructure::Structure"]}]; if (window.register_implementors) {window.register_implementors(implementors);} else {window.pending_implementors = implementors;}})() \ No newline at end of file diff --git a/light.css b/light.css index fa73fe2..050c4f2 100644 --- a/light.css +++ b/light.css @@ -1 +1 @@ - body{background-color:white;color:black;}h1,h2,h3:not(.impl):not(.method):not(.type):not(.tymethod),h4:not(.method):not(.type):not(.tymethod){color:black;}h1.fqn{border-bottom-color:#D5D5D5;}h2,h3:not(.impl):not(.method):not(.type):not(.tymethod),h4:not(.method):not(.type):not(.tymethod){border-bottom-color:#DDDDDD;}.in-band{background-color:white;}.invisible{background:rgba(0,0,0,0);}.docblock code,.docblock-short code{background-color:#F5F5F5;}pre{background-color:#F5F5F5;}.sidebar{background-color:#F1F1F1;}*{scrollbar-color:rgba(36,37,39,0.6) #e6e6e6;}.sidebar{scrollbar-color:rgba(36,37,39,0.6) #d9d9d9;}.logo-container.rust-logo>img{}::-webkit-scrollbar-track{background-color:#ecebeb;}::-webkit-scrollbar-thumb{background-color:rgba(36,37,39,0.6);}.sidebar::-webkit-scrollbar-track{background-color:#dcdcdc;}.sidebar::-webkit-scrollbar-thumb{background-color:rgba(36,37,39,0.6);}.sidebar .current{background-color:#fff;}.source .sidebar{background-color:#fff;}.sidebar .location{border-color:#000;background-color:#fff;color:#333;}.sidebar .version{border-bottom-color:#DDD;}.sidebar-title{border-top-color:#777;border-bottom-color:#777;}.block a:hover{background:#F5F5F5;}.line-numbers span{color:#c67e2d;}.line-numbers .line-highlighted{background-color:#f6fdb0 !important;}.docblock h1,.docblock h2,.docblock h3,.docblock h4,.docblock h5{border-bottom-color:#ddd;}.docblock table,.docblock table td,.docblock table th{border-color:#ddd;}.content .method .where,.content .fn .where,.content .where.fmt-newline{color:#4E4C4C;}.content .highlighted{color:#000 !important;background-color:#ccc;}.content .highlighted a,.content .highlighted span{color:#000 !important;}.content .highlighted.trait{background-color:#c7b6ff;}.content .highlighted.traitalias{background-color:#c7b6ff;}.content .highlighted.mod,.content .highlighted.externcrate{background-color:#afc6e4;}.content .highlighted.enum{background-color:#b4d1b9;}.content .highlighted.struct{background-color:#e7b1a0;}.content .highlighted.union{background-color:#b7bd49;}.content .highlighted.fn,.content .highlighted.method,.content .highlighted.tymethod{background-color:#c6afb3;}.content .highlighted.type{background-color:#ffc891;}.content .highlighted.foreigntype{background-color:#f5c4ff;}.content .highlighted.attr,.content .highlighted.derive,.content .highlighted.macro{background-color:#8ce488;}.content .highlighted.constant,.content .highlighted.static{background-color:#c3e0ff;}.content .highlighted.primitive{background-color:#9aecff;}.content .highlighted.keyword{background-color:#f99650;}.content .item-info::before{color:#ccc;}.content span.enum,.content a.enum,.block a.current.enum{color:#508157;}.content span.struct,.content a.struct,.block a.current.struct{color:#ad448e;}.content span.type,.content a.type,.block a.current.type{color:#ba5d00;}.content span.foreigntype,.content a.foreigntype,.block a.current.foreigntype{color:#cd00e2;}.content span.attr,.content a.attr,.block a.current.attr,.content span.derive,.content a.derive,.block a.current.derive,.content span.macro,.content a.macro,.block a.current.macro{color:#068000;}.content span.union,.content a.union,.block a.current.union{color:#767b27;}.content span.constant,.content a.constant,.block a.current.constant,.content span.static,.content a.static,.block a.current.static{color:#546e8a;}.content span.primitive,.content a.primitive,.block a.current.primitive{color:#2c8093;}.content span.externcrate,.content span.mod,.content a.mod,.block a.current.mod{color:#4d76ae;}.content span.trait,.content a.trait,.block a.current.trait{color:#7c5af3;}.content span.traitalias,.content a.traitalias,.block a.current.traitalias{color:#6841f1;}.content span.fn,.content a.fn,.block a.current.fn,.content span.method,.content a.method,.block a.current.method,.content span.tymethod,.content a.tymethod,.block a.current.tymethod,.content .fnname{color:#9a6e31;}.content span.keyword,.content a.keyword,.block a.current.keyword{color:#de5249;}pre.rust .comment{color:#8E908C;}pre.rust .doccomment{color:#4D4D4C;}nav:not(.sidebar){border-bottom-color:#e0e0e0;}nav.main .current{border-top-color:#000;border-bottom-color:#000;}nav.main .separator{border:1px solid #000;}a{color:#000;}.docblock:not(.type-decl) a:not(.srclink):not(.test-arrow),.docblock-short a:not(.srclink):not(.test-arrow),.item-info a,#help a{color:#3873AD;}a.test-arrow{color:#f5f5f5;}.collapse-toggle{color:#999;}#crate-search{color:#555;background-color:white;border-color:#e0e0e0;box-shadow:0 0 0 1px #e0e0e0,0 0 0 2px transparent;}.search-input{color:#555;background-color:white;box-shadow:0 0 0 1px #e0e0e0,0 0 0 2px transparent;}.search-input:focus{border-color:#66afe9;}.search-focus:disabled{background-color:#e6e6e6;}#crate-search+.search-input:focus{box-shadow:0 0 8px #078dd8;}.module-item .stab{color:#000;}.stab.unstable{background:#FFF5D6;border-color:#FFC600;}.stab.deprecated{background:#F3DFFF;border-color:#7F0087;}.stab.portability{background:#C4ECFF;border-color:#7BA5DB;}.stab.portability>code{color:#000;}#help>div{background:#e9e9e9;border-color:#bfbfbf;}#help>div>span{border-bottom-color:#bfbfbf;}.since{color:grey;}tr.result span.primitive::after,tr.result span.keyword::after{color:black;}.line-numbers :target{background-color:transparent;}pre.rust .kw{color:#8959A8;}pre.rust .kw-2,pre.rust .prelude-ty{color:#4271AE;}pre.rust .number,pre.rust .string{color:#718C00;}pre.rust .self,pre.rust .bool-val,pre.rust .prelude-val,pre.rust .attribute,pre.rust .attribute .ident{color:#C82829;}pre.rust .macro,pre.rust .macro-nonterminal{color:#3E999F;}pre.rust .lifetime{color:#B76514;}pre.rust .question-mark{color:#ff9011;}.example-wrap>pre.line-number{border-color:#c7c7c7;}a.test-arrow{background-color:rgba(78,139,202,0.2);}a.test-arrow:hover{background-color:#4e8bca;}.toggle-label{color:#999;}:target>code,:target>.in-band{background:#FDFFD3;border-right:3px solid #ffb44c;}pre.compile_fail{border-left:2px solid rgba(255,0,0,.5);}pre.compile_fail:hover,.information:hover+pre.compile_fail{border-left:2px solid #f00;}pre.should_panic{border-left:2px solid rgba(255,0,0,.5);}pre.should_panic:hover,.information:hover+pre.should_panic{border-left:2px solid #f00;}pre.ignore{border-left:2px solid rgba(255,142,0,.6);}pre.ignore:hover,.information:hover+pre.ignore{border-left:2px solid #ff9200;}.tooltip.compile_fail{color:rgba(255,0,0,.5);}.information>.compile_fail:hover{color:#f00;}.tooltip.should_panic{color:rgba(255,0,0,.5);}.information>.should_panic:hover{color:#f00;}.tooltip.ignore{color:rgba(255,142,0,.6);}.information>.ignore:hover{color:#ff9200;}.search-failed a{color:#0089ff;}.tooltip::after{background-color:#000;color:#fff;}.tooltip::before{border-color:transparent black transparent transparent;}.notable-traits-tooltiptext{background-color:#eee;border-color:#999;}#titles>button:not(.selected){background-color:#e6e6e6;border-top-color:#e6e6e6;}#titles>button:hover,#titles>button.selected{background-color:#ffffff;border-top-color:#0089ff;}#titles>button>div.count{color:#888;}@media (max-width:700px){.sidebar-menu{background-color:#F1F1F1;border-bottom-color:#e0e0e0;border-right-color:#e0e0e0;}.sidebar-elems{background-color:#F1F1F1;border-right-color:#000;}#sidebar-filler{background-color:#F1F1F1;border-bottom-color:#e0e0e0;}}kbd{color:#000;background-color:#fafbfc;border-color:#d1d5da;border-bottom-color:#c6cbd1;box-shadow-color:#c6cbd1;}#theme-picker,#settings-menu,.help-button{border-color:#e0e0e0;background-color:#fff;}#theme-picker:hover,#theme-picker:focus,#settings-menu:hover,#settings-menu:focus,.help-button:hover,.help-button:focus{border-color:#717171;}#theme-choices{border-color:#ccc;background-color:#fff;}#theme-choices>button:not(:first-child){border-top-color:#e0e0e0;}#theme-choices>button:hover,#theme-choices>button:focus{background-color:#eee;}@media (max-width:700px){#theme-picker{background:#fff;}}#all-types{background-color:#fff;}#all-types:hover{background-color:#f9f9f9;}.search-results td span.alias{color:#000;}.search-results td span.grey{color:#999;}#sidebar-toggle{background-color:#F1F1F1;}#sidebar-toggle:hover{background-color:#E0E0E0;}#source-sidebar{background-color:#F1F1F1;}#source-sidebar>.title{border-bottom-color:#ccc;}div.files>a:hover,div.name:hover{background-color:#E0E0E0;}div.files>.selected{background-color:#fff;}.setting-line>.title{border-bottom-color:#D5D5D5;} \ No newline at end of file + body{background-color:white;color:black;}h1,h2,h3:not(.impl):not(.method):not(.type):not(.tymethod),h4:not(.method):not(.type):not(.tymethod){color:black;}h1.fqn{border-bottom-color:#D5D5D5;}h2,h3:not(.impl):not(.method):not(.type):not(.tymethod),h4:not(.method):not(.type):not(.tymethod){border-bottom-color:#DDDDDD;}.in-band{background-color:white;}.invisible{background:rgba(0,0,0,0);}.docblock code,.docblock-short code{background-color:#F5F5F5;}pre{background-color:#F5F5F5;}.sidebar{background-color:#F1F1F1;}*{scrollbar-color:rgba(36,37,39,0.6) #e6e6e6;}.sidebar{scrollbar-color:rgba(36,37,39,0.6) #d9d9d9;}.logo-container.rust-logo>img{}::-webkit-scrollbar-track{background-color:#ecebeb;}::-webkit-scrollbar-thumb{background-color:rgba(36,37,39,0.6);}.sidebar::-webkit-scrollbar-track{background-color:#dcdcdc;}.sidebar::-webkit-scrollbar-thumb{background-color:rgba(36,37,39,0.6);}.sidebar .current{background-color:#fff;}.source .sidebar{background-color:#fff;}.sidebar .location{border-color:#000;background-color:#fff;color:#333;}.sidebar .version{border-bottom-color:#DDD;}.sidebar-title{border-top-color:#777;border-bottom-color:#777;}.block a:hover{background:#F5F5F5;}.line-numbers span{color:#c67e2d;}.line-numbers .line-highlighted{background-color:#f6fdb0 !important;}.docblock h1,.docblock h2,.docblock h3,.docblock h4,.docblock h5{border-bottom-color:#ddd;}.docblock table,.docblock table td,.docblock table th{border-color:#ddd;}.content .method .where,.content .fn .where,.content .where.fmt-newline{color:#4E4C4C;}.content .highlighted{color:#000 !important;background-color:#ccc;}.content .highlighted a,.content .highlighted span{color:#000 !important;}.content .highlighted.trait{background-color:#c7b6ff;}.content .highlighted.traitalias{background-color:#c7b6ff;}.content .highlighted.mod,.content .highlighted.externcrate{background-color:#afc6e4;}.content .highlighted.enum{background-color:#b4d1b9;}.content .highlighted.struct{background-color:#e7b1a0;}.content .highlighted.union{background-color:#b7bd49;}.content .highlighted.fn,.content .highlighted.method,.content .highlighted.tymethod{background-color:#c6afb3;}.content .highlighted.type{background-color:#ffc891;}.content .highlighted.foreigntype{background-color:#f5c4ff;}.content .highlighted.attr,.content .highlighted.derive,.content .highlighted.macro{background-color:#8ce488;}.content .highlighted.constant,.content .highlighted.static{background-color:#c3e0ff;}.content .highlighted.primitive{background-color:#9aecff;}.content .highlighted.keyword{background-color:#f99650;}.content .item-info::before{color:#ccc;}.content span.enum,.content a.enum,.block a.current.enum{color:#508157;}.content span.struct,.content a.struct,.block a.current.struct{color:#ad448e;}.content span.type,.content a.type,.block a.current.type{color:#ba5d00;}.content span.foreigntype,.content a.foreigntype,.block a.current.foreigntype{color:#cd00e2;}.content span.attr,.content a.attr,.block a.current.attr,.content span.derive,.content a.derive,.block a.current.derive,.content span.macro,.content a.macro,.block a.current.macro{color:#068000;}.content span.union,.content a.union,.block a.current.union{color:#767b27;}.content span.constant,.content a.constant,.block a.current.constant,.content span.static,.content a.static,.block a.current.static{color:#546e8a;}.content span.primitive,.content a.primitive,.block a.current.primitive{color:#2c8093;}.content span.externcrate,.content span.mod,.content a.mod,.block a.current.mod{color:#4d76ae;}.content span.trait,.content a.trait,.block a.current.trait{color:#7c5af3;}.content span.traitalias,.content a.traitalias,.block a.current.traitalias{color:#6841f1;}.content span.fn,.content a.fn,.block a.current.fn,.content span.method,.content a.method,.block a.current.method,.content span.tymethod,.content a.tymethod,.block a.current.tymethod,.content .fnname{color:#9a6e31;}.content span.keyword,.content a.keyword,.block a.current.keyword{color:#de5249;}pre.rust .comment{color:#8E908C;}pre.rust .doccomment{color:#4D4D4C;}nav:not(.sidebar){border-bottom-color:#e0e0e0;}nav.main .current{border-top-color:#000;border-bottom-color:#000;}nav.main .separator{border:1px solid #000;}a{color:#000;}.docblock:not(.type-decl) a:not(.srclink):not(.test-arrow),.docblock-short a:not(.srclink):not(.test-arrow),.item-info a,#help a{color:#3873AD;}a.test-arrow{color:#f5f5f5;}.collapse-toggle{color:#999;}#crate-search{color:#555;background-color:white;border-color:#e0e0e0;box-shadow:0 0 0 1px #e0e0e0,0 0 0 2px transparent;}.search-input{color:#555;background-color:white;box-shadow:0 0 0 1px #e0e0e0,0 0 0 2px transparent;}.search-input:focus{border-color:#66afe9;}.search-focus:disabled{background-color:#e6e6e6;}#crate-search+.search-input:focus{box-shadow:0 0 8px #078dd8;}.module-item .stab{color:#000;}.stab.unstable{background:#FFF5D6;border-color:#FFC600;}.stab.deprecated{background:#F3DFFF;border-color:#7F0087;}.stab.portability{background:#C4ECFF;border-color:#7BA5DB;}.stab.portability>code{background:none;}#help>div{background:#e9e9e9;border-color:#bfbfbf;}#help>div>span{border-bottom-color:#bfbfbf;}.since{color:grey;}tr.result span.primitive::after,tr.result span.keyword::after{color:black;}.line-numbers :target{background-color:transparent;}pre.rust .kw{color:#8959A8;}pre.rust .kw-2,pre.rust .prelude-ty{color:#4271AE;}pre.rust .number,pre.rust .string{color:#718C00;}pre.rust .self,pre.rust .bool-val,pre.rust .prelude-val,pre.rust .attribute,pre.rust .attribute .ident{color:#C82829;}pre.rust .macro,pre.rust .macro-nonterminal{color:#3E999F;}pre.rust .lifetime{color:#B76514;}pre.rust .question-mark{color:#ff9011;}.example-wrap>pre.line-number{border-color:#c7c7c7;}a.test-arrow{background-color:rgba(78,139,202,0.2);}a.test-arrow:hover{background-color:#4e8bca;}.toggle-label{color:#999;}:target>code,:target>.in-band{background:#FDFFD3;border-right:3px solid #ffb44c;}pre.compile_fail{border-left:2px solid rgba(255,0,0,.5);}pre.compile_fail:hover,.information:hover+pre.compile_fail{border-left:2px solid #f00;}pre.should_panic{border-left:2px solid rgba(255,0,0,.5);}pre.should_panic:hover,.information:hover+pre.should_panic{border-left:2px solid #f00;}pre.ignore{border-left:2px solid rgba(255,142,0,.6);}pre.ignore:hover,.information:hover+pre.ignore{border-left:2px solid #ff9200;}.tooltip.compile_fail{color:rgba(255,0,0,.5);}.information>.compile_fail:hover{color:#f00;}.tooltip.should_panic{color:rgba(255,0,0,.5);}.information>.should_panic:hover{color:#f00;}.tooltip.ignore{color:rgba(255,142,0,.6);}.information>.ignore:hover{color:#ff9200;}.search-failed a{color:#0089ff;}.tooltip::after{background-color:#000;color:#fff;}.tooltip::before{border-color:transparent black transparent transparent;}.notable-traits-tooltiptext{background-color:#eee;border-color:#999;}#titles>button:not(.selected){background-color:#e6e6e6;border-top-color:#e6e6e6;}#titles>button:hover,#titles>button.selected{background-color:#ffffff;border-top-color:#0089ff;}#titles>button>div.count{color:#888;}@media (max-width:700px){.sidebar-menu{background-color:#F1F1F1;border-bottom-color:#e0e0e0;border-right-color:#e0e0e0;}.sidebar-elems{background-color:#F1F1F1;border-right-color:#000;}#sidebar-filler{background-color:#F1F1F1;border-bottom-color:#e0e0e0;}}kbd{color:#000;background-color:#fafbfc;border-color:#d1d5da;border-bottom-color:#c6cbd1;box-shadow-color:#c6cbd1;}#theme-picker,#settings-menu,.help-button{border-color:#e0e0e0;background-color:#fff;}#theme-picker:hover,#theme-picker:focus,#settings-menu:hover,#settings-menu:focus,.help-button:hover,.help-button:focus{border-color:#717171;}#theme-choices{border-color:#ccc;background-color:#fff;}#theme-choices>button:not(:first-child){border-top-color:#e0e0e0;}#theme-choices>button:hover,#theme-choices>button:focus{background-color:#eee;}@media (max-width:700px){#theme-picker{background:#fff;}}#all-types{background-color:#fff;}#all-types:hover{background-color:#f9f9f9;}.search-results td span.alias{color:#000;}.search-results td span.grey{color:#999;}#sidebar-toggle{background-color:#F1F1F1;}#sidebar-toggle:hover{background-color:#E0E0E0;}#source-sidebar{background-color:#F1F1F1;}#source-sidebar>.title{border-bottom-color:#ccc;}div.files>a:hover,div.name:hover{background-color:#E0E0E0;}div.files>.selected{background-color:#fff;}.setting-line>.title{border-bottom-color:#D5D5D5;} \ No newline at end of file diff --git a/log/all.html b/log/all.html index 089e682..6a2e1ed 100644 --- a/log/all.html +++ b/log/all.html @@ -1,4 +1,5 @@ -List of all items in this crate

[−] +List of all items in this crate

List of all items[−] - List of all items

Structs

Enums

Traits

Macros

Functions

Constants

\ No newline at end of file +

Structs

Enums

Traits

Macros

Functions

Constants

+ \ No newline at end of file diff --git a/log/constant.STATIC_MAX_LEVEL.html b/log/constant.STATIC_MAX_LEVEL.html index 07f1c54..be79565 100644 --- a/log/constant.STATIC_MAX_LEVEL.html +++ b/log/constant.STATIC_MAX_LEVEL.html @@ -1,7 +1,8 @@ -log::STATIC_MAX_LEVEL - Rust

[−][src]Constant log::STATIC_MAX_LEVEL

pub const STATIC_MAX_LEVEL: LevelFilter;

The statically resolved maximum log level.

+log::STATIC_MAX_LEVEL - Rust

Constant log::STATIC_MAX_LEVEL[−][src]

pub const STATIC_MAX_LEVEL: LevelFilter;

The statically resolved maximum log level.

See the crate level documentation for information on how to configure this.

This value is checked by the log macros, but not by the Logger returned by the logger function. Code that manually calls functions on that value should compare the level against this value.

-
\ No newline at end of file +
+ \ No newline at end of file diff --git a/log/enum.Level.html b/log/enum.Level.html index cb4ae5f..3a8bf17 100644 --- a/log/enum.Level.html +++ b/log/enum.Level.html @@ -1,5 +1,5 @@ -log::Level - Rust

[−][src]Enum log::Level

#[repr(usize)]pub enum Level {
+log::Level - Rust
Enum log::Level[−][src]
#[repr(usize)]pub enum Level {
     Error,
     Warn,
     Info,
@@ -12,41 +12,41 @@
 LevelFilter.

 

                    Variants

-
Error
The "error" level.

+
Error
The “error” level.

 
Designates very serious errors.

-
Warn
The "warn" level.

+
Warn
The “warn” level.

 
Designates hazardous situations.

-
Info
The "info" level.

+
Info
The “info” level.

 
Designates useful information.

-
Debug
The "debug" level.

+
Debug
The “debug” level.

 
Designates lower priority information.

-
Trace
The "trace" level.

+
Trace
The “trace” level.

 
Designates very low priority, often extremely verbose, information.

 
Implementations
impl Level[src]
pub fn max() -> Level[src]
Returns the most verbose logging level.

 
pub fn to_level_filter(&self) -> LevelFilter[src]
Converts the Level to the equivalent LevelFilter.

 
pub fn as_str(&self) -> &'static str[src]
Returns the string representation of the Level.

 
This returns the same string as the fmt::Display implementation.

 
Trait Implementations
impl Clone for Level[src]
impl Copy for Level[src]
impl Debug for Level[src]
impl Display for Level[src]
impl Eq for Level[src]
impl FromStr for Level[src]
type Err = ParseLevelError
The associated error which can be returned from parsing.

 
impl Hash for Level[src]
impl Ord for Level[src]
impl PartialEq<Level> for Level[src]
impl PartialEq<Level> for LevelFilter[src]
impl PartialEq<LevelFilter> for Level[src]
impl PartialOrd<Level> for Level[src]
impl StructuralEq for Level[src]
Auto Trait Implementations
impl Send for Level[src]
impl Sync for Level[src]
impl Unpin for Level[src]
Blanket Implementations
impl<T> Any for T where
    T: 'static + ?Sized, [src]
impl<T> Borrow<T> for T where
    T: ?Sized, [src]
impl<T> BorrowMut<T> for T where
    T: ?Sized, [src]
impl<T> From<T> for T[src]
impl<T, U> Into<U> for T where
    U: From<T>, [src]
impl<T, U> TryFrom<U> for T where
    U: Into<T>, [src]
type Error = Infallible
The type returned in the event of a conversion error.

-
impl<T, U> TryInto<U> for T where
    U: TryFrom<T>, [src]
type Error = <U as TryFrom<T>>::Error
The type returned in the event of a conversion error.

-

\ No newline at end of file
+

impl StructuralEq for Level[src]

Auto Trait Implementations

impl Send for Level

impl Sync for Level

impl Unpin for Level

Blanket Implementations

impl<T> Any for T where
    T: 'static + ?Sized, [src]

impl<T> Borrow<T> for T where
    T: ?Sized, [src]

impl<T> BorrowMut<T> for T where
    T: ?Sized, [src]

impl<T> From<T> for T[src]

impl<T, U> Into<U> for T where
    U: From<T>, [src]

impl<T, U> TryFrom<U> for T where
    U: Into<T>, [src]

type Error = Infallible

The type returned in the event of a conversion error.

+

impl<T, U> TryInto<U> for T where
    U: TryFrom<T>, [src]

type Error = <U as TryFrom<T>>::Error

The type returned in the event of a conversion error.

+
+ \ No newline at end of file diff --git a/log/enum.LevelFilter.html b/log/enum.LevelFilter.html index 529c025..e7c4dad 100644 --- a/log/enum.LevelFilter.html +++ b/log/enum.LevelFilter.html @@ -1,5 +1,5 @@ -log::LevelFilter - Rust

[−][src]Enum log::LevelFilter

#[repr(usize)]pub enum LevelFilter {
+log::LevelFilter - Rust
Enum log::LevelFilter[−][src]
#[repr(usize)]pub enum LevelFilter {
     Off,
     Error,
     Warn,
@@ -23,26 +23,26 @@ to get and set the maximum log level with max_
 
pub fn as_str(&self) -> &'static str[src]
Returns the string representation of the LevelFilter.

 
This returns the same string as the fmt::Display implementation.

Trait Implementations

impl Clone for LevelFilter[src]

impl Copy for LevelFilter[src]

impl Debug for LevelFilter[src]

impl Display for LevelFilter[src]

impl Eq for LevelFilter[src]

impl FromStr for LevelFilter[src]

type Err = ParseLevelError

The associated error which can be returned from parsing.

impl Hash for LevelFilter[src]

impl Ord for LevelFilter[src]

impl PartialEq<Level> for LevelFilter[src]

impl PartialEq<LevelFilter> for Level[src]

impl PartialEq<LevelFilter> for LevelFilter[src]

impl PartialOrd<Level> for LevelFilter[src]

impl StructuralEq for LevelFilter[src]

Auto Trait Implementations

Blanket Implementations

impl<T> Any for T where
    T: 'static + ?Sized, [src]

impl<T> Borrow<T> for T where
    T: ?Sized, [src]

impl<T> BorrowMut<T> for T where
    T: ?Sized, [src]

impl<T> From<T> for T[src]

impl<T, U> Into<U> for T where
    U: From<T>, [src]

impl<T, U> TryFrom<U> for T where
    U: Into<T>, [src]

type Error = Infallible

The type returned in the event of a conversion error.

-

impl<T, U> TryInto<U> for T where
    U: TryFrom<T>, [src]

type Error = <U as TryFrom<T>>::Error

The type returned in the event of a conversion error.

-
\ No newline at end of file +

impl StructuralEq for LevelFilter[src]

Auto Trait Implementations

Blanket Implementations

impl<T> Any for T where
    T: 'static + ?Sized, [src]

impl<T> Borrow<T> for T where
    T: ?Sized, [src]

impl<T> BorrowMut<T> for T where
    T: ?Sized, [src]

impl<T> From<T> for T[src]

impl<T, U> Into<U> for T where
    U: From<T>, [src]

impl<T, U> TryFrom<U> for T where
    U: Into<T>, [src]

type Error = Infallible

The type returned in the event of a conversion error.

+

impl<T, U> TryInto<U> for T where
    U: TryFrom<T>, [src]

type Error = <U as TryFrom<T>>::Error

The type returned in the event of a conversion error.

+
+ \ No newline at end of file diff --git a/log/fn.logger.html b/log/fn.logger.html index 9ccaba4..2c57e6c 100644 --- a/log/fn.logger.html +++ b/log/fn.logger.html @@ -1,4 +1,5 @@ -log::logger - Rust

[−][src]Function log::logger

pub fn logger() -> &'static dyn Log

Returns a reference to the logger.

+log::logger - Rust

Function log::logger[−][src]

pub fn logger() -> &'static dyn Log

Returns a reference to the logger.

If a logger has not been set, a no-op implementation is returned.

-
\ No newline at end of file +
+ \ No newline at end of file diff --git a/log/fn.max_level.html b/log/fn.max_level.html index db0d8bc..801cd4f 100644 --- a/log/fn.max_level.html +++ b/log/fn.max_level.html @@ -1,6 +1,7 @@ -log::max_level - Rust

[−][src]Function log::max_level

pub fn max_level() -> LevelFilter

Returns the current maximum log level.

+log::max_level - Rust

Function log::max_level[−][src]

pub fn max_level() -> LevelFilter

Returns the current maximum log level.

The log!, error!, warn!, info!, debug!, and trace! macros check this value and discard any message logged at a higher level. The maximum log level is set by the set_max_level function.

-
\ No newline at end of file +
+ \ No newline at end of file diff --git a/log/fn.set_logger.html b/log/fn.set_logger.html index dce8f04..12aa520 100644 --- a/log/fn.set_logger.html +++ b/log/fn.set_logger.html @@ -1,5 +1,5 @@ -log::set_logger - Rust

[−][src]Function log::set_logger

pub fn set_logger(logger: &'static dyn Log) -> Result<(), SetLoggerError>

Sets the global logger to a &'static Log.

+log::set_logger - Rust

Function log::set_logger[−][src]

pub fn set_logger(logger: &'static dyn Log) -> Result<(), SetLoggerError>

Sets the global logger to a &'static Log.

This function may only be called once in the lifetime of a program. Any log events that occur before the call to set_logger completes will be ignored.

This function does not typically need to be called manually. Logger @@ -39,4 +39,5 @@ targets, set_logger_racy will info!("hello log"); warn!("warning"); error!("oops");

-
\ No newline at end of file +
+ \ No newline at end of file diff --git a/log/fn.set_logger_racy.html b/log/fn.set_logger_racy.html index 094143c..9357348 100644 --- a/log/fn.set_logger_racy.html +++ b/log/fn.set_logger_racy.html @@ -1,5 +1,5 @@ -log::set_logger_racy - Rust

[−][src]Function log::set_logger_racy

pub unsafe fn set_logger_racy(
    logger: &'static dyn Log
) -> Result<(), SetLoggerError>

A thread-unsafe version of set_logger.

+log::set_logger_racy - Rust

Function log::set_logger_racy[−][src]

pub unsafe fn set_logger_racy(
    logger: &'static dyn Log
) -> Result<(), SetLoggerError>

A thread-unsafe version of set_logger.

This function is available on all platforms, even those that do not have support for atomics that is needed by set_logger.

In almost all cases, set_logger should be preferred.

@@ -10,4 +10,5 @@ function is called while this function still executes.

threads, and (on embedded) that interrupts are disabled.

It is safe to use other logging functions while this function runs (including all logging macros).

-
\ No newline at end of file +
+ \ No newline at end of file diff --git a/log/fn.set_max_level.html b/log/fn.set_max_level.html index be2a9d4..207f2aa 100644 --- a/log/fn.set_max_level.html +++ b/log/fn.set_max_level.html @@ -1,4 +1,5 @@ -log::set_max_level - Rust

[−][src]Function log::set_max_level

pub fn set_max_level(level: LevelFilter)

Sets the global maximum log level.

+log::set_max_level - Rust

Function log::set_max_level[−][src]

pub fn set_max_level(level: LevelFilter)

Sets the global maximum log level.

Generally, this should only be called by the active logging implementation.

-
\ No newline at end of file +
+ \ No newline at end of file diff --git a/log/index.html b/log/index.html index 6dfc66d..4c14b34 100644 --- a/log/index.html +++ b/log/index.html @@ -1,10 +1,10 @@ -log - Rust

[−][src]Crate log

A lightweight logging facade.

+log - Rust

Crate log[−][src]

A lightweight logging facade.

The log crate provides a single logging API that abstracts over the actual logging implementation. Libraries can use the logging API provided by this crate, and the consumer of those libraries can choose the logging implementation that is most suitable for its use case.

-

If no logging implementation is selected, the facade falls back to a "noop" +

If no logging implementation is selected, the facade falls back to a “noop” implementation that ignores all log messages. The overhead in this case is very small - just an integer load, comparison and jump.

A log request consists of a target, a level, and a body. A target is a @@ -79,7 +79,7 @@ here are some of the most popular ones:

Implementing a Logger

-

Loggers implement the Log trait. Here's a very basic example that simply +

Loggers implement the Log trait. Here’s a very basic example that simply logs all messages at the Error, Warn or Info levels to stdout:

@@ -105,9 +105,9 @@ logs all messages at the Error, Loggers are installed by calling the set_logger function. The maximum log level also needs to be adjusted via the set_max_level function. The logging facade uses this as an optimization to improve performance of log -messages at levels that are disabled. It's important to set it, as it +messages at levels that are disabled. It’s important to set it, as it defaults to Off, so no log messages will ever be captured! -In the case of our example logger, we'll want to set the maximum log level +In the case of our example logger, we’ll want to set the maximum log level to Info, since we ignore any Debug or Trace level log messages. A logging implementation should provide a function that wraps a call to set_logger and @@ -156,8 +156,8 @@ This level is configured separately for release and debug builds. The features a

These features control the value of the STATIC_MAX_LEVEL constant. The logging macros check this value before logging a message. By default, no levels are disabled.

-

Libraries should avoid using the max level features because they're global and can't be changed -once they're set.

+

Libraries should avoid using the max level features because they’re global and can’t be changed +once they’re set.

For example, a crate can disable trace level logs in debug builds and trace, debug, and info level logs in release builds with the following configuration:

[dependencies]
@@ -191,8 +191,8 @@ be logged.

 
Structs

 
Metadata
Metadata about a log message.

 
MetadataBuilder
Builder for Metadata.

-
ParseLevelError
The type returned by from_str when the string doesn't match any of the log levels.

-
Record
The "payload" of a log message.

+
ParseLevelError
The type returned by from_str when the string doesn’t match any of the log levels.

+
Record
The “payload” of a log message.

 
RecordBuilder
Builder for Record.

 
SetLoggerError
The type returned by set_logger if set_logger has already been called.

 
Enums

@@ -208,4 +208,5 @@ be logged.

 set_logger
Sets the global logger to a &'static Log.

 set_logger_racy⚠
A thread-unsafe version of set_logger.

 set_max_level
Sets the global maximum log level.

-
\ No newline at end of file +
+ \ No newline at end of file diff --git a/log/macro.debug.html b/log/macro.debug.html index b82e99c..4dd638e 100644 --- a/log/macro.debug.html +++ b/log/macro.debug.html @@ -1,5 +1,5 @@ -log::debug - Rust

[−][src]Macro log::debug

+log::debug - Rust
Macro log::debug[−][src]
 macro_rules! debug {
     (target: $target:expr, $($arg:tt)+) => { ... };
     ($($arg:tt)+) => { ... };
@@ -13,4 +13,5 @@
 
 debug!("New position: x: {}, y: {}", pos.x, pos.y);
 debug!(target: "app_events", "New position: x: {}, y: {}", pos.x, pos.y);

-

\ No newline at end of file
+
+ \ No newline at end of file diff --git a/log/macro.error.html b/log/macro.error.html index 0a330ae..27eea1a 100644 --- a/log/macro.error.html +++ b/log/macro.error.html @@ -1,5 +1,5 @@ -log::error - Rust

[−][src]Macro log::error

+log::error - Rust
Macro log::error[−][src]
 macro_rules! error {
     (target: $target:expr, $($arg:tt)+) => { ... };
     ($($arg:tt)+) => { ... };
@@ -13,4 +13,5 @@
 
 error!("Error: {} on port {}", err_info, port);
 error!(target: "app_events", "App Error: {}, Port: {}", err_info, 22);

-

\ No newline at end of file
+
+ \ No newline at end of file diff --git a/log/macro.info.html b/log/macro.info.html index d224a18..4bedddd 100644 --- a/log/macro.info.html +++ b/log/macro.info.html @@ -1,5 +1,5 @@ -log::info - Rust

[−][src]Macro log::info

+log::info - Rust
Macro log::info[−][src]
 macro_rules! info {
     (target: $target:expr, $($arg:tt)+) => { ... };
     ($($arg:tt)+) => { ... };
@@ -14,4 +14,5 @@
 info!("Connected to port {} at {} Mb/s", conn_info.port, conn_info.speed);
 info!(target: "connection_events", "Successfull connection, port: {}, speed: {}",
       conn_info.port, conn_info.speed);

-

\ No newline at end of file
+
+ \ No newline at end of file diff --git a/log/macro.log.html b/log/macro.log.html index e7403a7..ca90844 100644 --- a/log/macro.log.html +++ b/log/macro.log.html @@ -1,5 +1,5 @@ -log::log - Rust

[−][src]Macro log::log

+log::log - Rust
Macro log::log[−][src]
 macro_rules! log {
     (target: $target:expr, $lvl:expr, $($arg:tt)+) => { ... };
     ($lvl:expr, $($arg:tt)+) => { ... };
@@ -17,4 +17,5 @@ based argument list.

 log!(Level::Error, "Received errors: {}, {}", data.0, data.1);
 log!(target: "app_events", Level::Warn, "App warning: {}, {}, {}",
     data.0, data.1, private_data);

-

\ No newline at end of file
+
+ \ No newline at end of file diff --git a/log/macro.log_enabled.html b/log/macro.log_enabled.html index 6a3c6f0..6bd433f 100644 --- a/log/macro.log_enabled.html +++ b/log/macro.log_enabled.html @@ -1,5 +1,5 @@ -log::log_enabled - Rust

[−][src]Macro log::log_enabled

+log::log_enabled - Rust
Macro log::log_enabled[−][src]
 macro_rules! log_enabled {
     (target: $target:expr, $lvl:expr) => { ... };
     ($lvl:expr) => { ... };
@@ -21,4 +21,5 @@ the message would be ignored anyway.

    let data = expensive_call();
    debug!(target: "Global", "expensive debug data: {} {}", data.x, data.y);
 }

-

\ No newline at end of file
+
+ \ No newline at end of file diff --git a/log/macro.trace.html b/log/macro.trace.html index 3e6d6f2..5780403 100644 --- a/log/macro.trace.html +++ b/log/macro.trace.html @@ -1,5 +1,5 @@ -log::trace - Rust

[−][src]Macro log::trace

+log::trace - Rust
Macro log::trace[−][src]
 macro_rules! trace {
     (target: $target:expr, $($arg:tt)+) => { ... };
     ($($arg:tt)+) => { ... };
@@ -15,4 +15,5 @@
 trace!(target: "app_events", "x is {} and y is {}",
        if pos.x >= 0.0 { "positive" } else { "negative" },
        if pos.y >= 0.0 { "positive" } else { "negative" });

-

\ No newline at end of file
+
+ \ No newline at end of file diff --git a/log/macro.warn.html b/log/macro.warn.html index f4bf92a..f748911 100644 --- a/log/macro.warn.html +++ b/log/macro.warn.html @@ -1,5 +1,5 @@ -log::warn - Rust

[−][src]Macro log::warn

+log::warn - Rust
Macro log::warn[−][src]
 macro_rules! warn {
     (target: $target:expr, $($arg:tt)+) => { ... };
     ($($arg:tt)+) => { ... };
@@ -13,4 +13,5 @@
 
 warn!("Warning! {}!", warn_description);
 warn!(target: "input_events", "App received warning: {}", warn_description);

-

\ No newline at end of file
+
+ \ No newline at end of file diff --git a/log/sidebar-items.js b/log/sidebar-items.js index b3aff47..3674d26 100644 --- a/log/sidebar-items.js +++ b/log/sidebar-items.js @@ -1 +1 @@ -initSidebarItems({"constant":[["STATIC_MAX_LEVEL","The statically resolved maximum log level."]],"enum":[["Level","An enum representing the available verbosity levels of the logger."],["LevelFilter","An enum representing the available verbosity level filters of the logger."]],"fn":[["logger","Returns a reference to the logger."],["max_level","Returns the current maximum log level."],["set_logger","Sets the global logger to a `&'static Log`."],["set_logger_racy","A thread-unsafe version of `set_logger`."],["set_max_level","Sets the global maximum log level."]],"macro":[["debug","Logs a message at the debug level."],["error","Logs a message at the error level."],["info","Logs a message at the info level."],["log","The standard logging macro."],["log_enabled","Determines if a message logged at the specified level in that module will be logged."],["trace","Logs a message at the trace level."],["warn","Logs a message at the warn level."]],"struct":[["Metadata","Metadata about a log message."],["MetadataBuilder","Builder for `Metadata`."],["ParseLevelError","The type returned by `from_str` when the string doesn't match any of the log levels."],["Record","The \"payload\" of a log message."],["RecordBuilder","Builder for `Record`."],["SetLoggerError","The type returned by `set_logger` if `set_logger` has already been called."]],"trait":[["Log","A trait encapsulating the operations required of a logger."]]}); \ No newline at end of file +initSidebarItems({"constant":[["STATIC_MAX_LEVEL","The statically resolved maximum log level."]],"enum":[["Level","An enum representing the available verbosity levels of the logger."],["LevelFilter","An enum representing the available verbosity level filters of the logger."]],"fn":[["logger","Returns a reference to the logger."],["max_level","Returns the current maximum log level."],["set_logger","Sets the global logger to a `&'static Log`."],["set_logger_racy","A thread-unsafe version of `set_logger`."],["set_max_level","Sets the global maximum log level."]],"macro":[["debug","Logs a message at the debug level."],["error","Logs a message at the error level."],["info","Logs a message at the info level."],["log","The standard logging macro."],["log_enabled","Determines if a message logged at the specified level in that module will be logged."],["trace","Logs a message at the trace level."],["warn","Logs a message at the warn level."]],"struct":[["Metadata","Metadata about a log message."],["MetadataBuilder","Builder for `Metadata`."],["ParseLevelError","The type returned by `from_str` when the string doesn’t match any of the log levels."],["Record","The “payload” of a log message."],["RecordBuilder","Builder for `Record`."],["SetLoggerError","The type returned by `set_logger` if `set_logger` has already been called."]],"trait":[["Log","A trait encapsulating the operations required of a logger."]]}); \ No newline at end of file diff --git a/log/struct.Metadata.html b/log/struct.Metadata.html index 9599922..1b44367 100644 --- a/log/struct.Metadata.html +++ b/log/struct.Metadata.html @@ -1,11 +1,11 @@ -log::Metadata - Rust

[−][src]Struct log::Metadata

pub struct Metadata<'a> { /* fields omitted */ }

Metadata about a log message.

+log::Metadata - Rust

Struct log::Metadata[−][src]

pub struct Metadata<'a> { /* fields omitted */ }

Metadata about a log message.

Use

Metadata structs are created when users of the library use logging macros.

They are consumed by implementations of the Log trait in the enabled method.

-

Records use Metadata to determine the log message's severity +

Records use Metadata to determine the log message’s severity and target.

Users should use the log_enabled! macro in their code to avoid constructing expensive log messages.

@@ -32,31 +32,32 @@ constructing expensive log messages.

pub fn level(&self) -> Level[src]

The verbosity level of the message.

pub fn target(&self) -> &'a str[src]

The name of the target of the directive.

Trait Implementations

impl<'a> Clone for Metadata<'a>[src]

impl<'a> Debug for Metadata<'a>[src]

impl<'a> Eq for Metadata<'a>[src]

impl<'a> Hash for Metadata<'a>[src]

impl<'a> Ord for Metadata<'a>[src]

impl<'a> PartialEq<Metadata<'a>> for Metadata<'a>[src]

impl<'a> PartialOrd<Metadata<'a>> for Metadata<'a>[src]

impl<'a> StructuralEq for Metadata<'a>[src]

impl<'a> StructuralPartialEq for Metadata<'a>[src]

Auto Trait Implementations

impl<'a> Send for Metadata<'a>[src]

impl<'a> Sync for Metadata<'a>[src]

impl<'a> Unpin for Metadata<'a>[src]

Blanket Implementations

impl<T> Any for T where
    T: 'static + ?Sized, [src]

impl<T> Borrow<T> for T where
    T: ?Sized, [src]

impl<T> BorrowMut<T> for T where
    T: ?Sized, [src]

impl<T> From<T> for T[src]

impl<T, U> Into<U> for T where
    U: From<T>, [src]

impl<T, U> TryFrom<U> for T where
    U: Into<T>, [src]

type Error = Infallible

The type returned in the event of a conversion error.

-

impl<T, U> TryInto<U> for T where
    U: TryFrom<T>, [src]

type Error = <U as TryFrom<T>>::Error

The type returned in the event of a conversion error.

-
\ No newline at end of file +

impl<'a> StructuralEq for Metadata<'a>[src]

impl<'a> StructuralPartialEq for Metadata<'a>[src]

Auto Trait Implementations

impl<'a> Send for Metadata<'a>

impl<'a> Sync for Metadata<'a>

impl<'a> Unpin for Metadata<'a>

Blanket Implementations

impl<T> Any for T where
    T: 'static + ?Sized, [src]

impl<T> Borrow<T> for T where
    T: ?Sized, [src]

impl<T> BorrowMut<T> for T where
    T: ?Sized, [src]

impl<T> From<T> for T[src]

impl<T, U> Into<U> for T where
    U: From<T>, [src]

impl<T, U> TryFrom<U> for T where
    U: Into<T>, [src]

type Error = Infallible

The type returned in the event of a conversion error.

+

impl<T, U> TryInto<U> for T where
    U: TryFrom<T>, [src]

type Error = <U as TryFrom<T>>::Error

The type returned in the event of a conversion error.

+
+ \ No newline at end of file diff --git a/log/struct.MetadataBuilder.html b/log/struct.MetadataBuilder.html index c210e50..b694df7 100644 --- a/log/struct.MetadataBuilder.html +++ b/log/struct.MetadataBuilder.html @@ -1,6 +1,6 @@ -log::MetadataBuilder - Rust

[−][src]Struct log::MetadataBuilder

pub struct MetadataBuilder<'a> { /* fields omitted */ }

Builder for Metadata.

-

Typically should only be used by log library creators or for testing and "shim loggers". +log::MetadataBuilder - Rust

Struct log::MetadataBuilder[−][src]

pub struct MetadataBuilder<'a> { /* fields omitted */ }

Builder for Metadata.

+

Typically should only be used by log library creators or for testing and “shim loggers”. The MetadataBuilder can set the different parameters of a Metadata object, and returns the created object when build is called.

Example

@@ -22,28 +22,29 @@ the created object when build is called.

pub fn build(&self) -> Metadata<'a>[src]

Returns a Metadata object.

Trait Implementations

impl<'a> Debug for MetadataBuilder<'a>[src]

impl<'a> Eq for MetadataBuilder<'a>[src]

impl<'a> Hash for MetadataBuilder<'a>[src]

impl<'a> Ord for MetadataBuilder<'a>[src]

impl<'a> PartialEq<MetadataBuilder<'a>> for MetadataBuilder<'a>[src]

impl<'a> PartialOrd<MetadataBuilder<'a>> for MetadataBuilder<'a>[src]

impl<'a> StructuralEq for MetadataBuilder<'a>[src]

impl<'a> StructuralPartialEq for MetadataBuilder<'a>[src]

Auto Trait Implementations

impl<'a> Send for MetadataBuilder<'a>[src]

impl<'a> Sync for MetadataBuilder<'a>[src]

impl<'a> Unpin for MetadataBuilder<'a>[src]

Blanket Implementations

impl<T> Any for T where
    T: 'static + ?Sized, [src]

impl<T> Borrow<T> for T where
    T: ?Sized, [src]

impl<T> BorrowMut<T> for T where
    T: ?Sized, [src]

impl<T> From<T> for T[src]

impl<T, U> Into<U> for T where
    U: From<T>, [src]

impl<T, U> TryFrom<U> for T where
    U: Into<T>, [src]

type Error = Infallible

The type returned in the event of a conversion error.

-

impl<T, U> TryInto<U> for T where
    U: TryFrom<T>, [src]

type Error = <U as TryFrom<T>>::Error

The type returned in the event of a conversion error.

-
\ No newline at end of file +

impl<'a> StructuralEq for MetadataBuilder<'a>[src]

impl<'a> StructuralPartialEq for MetadataBuilder<'a>[src]

Auto Trait Implementations

impl<'a> Send for MetadataBuilder<'a>

impl<'a> Sync for MetadataBuilder<'a>

impl<'a> Unpin for MetadataBuilder<'a>

Blanket Implementations

impl<T> Any for T where
    T: 'static + ?Sized, [src]

impl<T> Borrow<T> for T where
    T: ?Sized, [src]

impl<T> BorrowMut<T> for T where
    T: ?Sized, [src]

impl<T> From<T> for T[src]

impl<T, U> Into<U> for T where
    U: From<T>, [src]

impl<T, U> TryFrom<U> for T where
    U: Into<T>, [src]

type Error = Infallible

The type returned in the event of a conversion error.

+

impl<T, U> TryInto<U> for T where
    U: TryFrom<T>, [src]

type Error = <U as TryFrom<T>>::Error

The type returned in the event of a conversion error.

+
+ \ No newline at end of file diff --git a/log/struct.ParseLevelError.html b/log/struct.ParseLevelError.html index 47c1d3a..f108159 100644 --- a/log/struct.ParseLevelError.html +++ b/log/struct.ParseLevelError.html @@ -1,17 +1,18 @@ -log::ParseLevelError - Rust

[−][src]Struct log::ParseLevelError

pub struct ParseLevelError(_);

The type returned by from_str when the string doesn't match any of the log levels.

+log::ParseLevelError - Rust

Struct log::ParseLevelError[−][src]

pub struct ParseLevelError(_);

The type returned by from_str when the string doesn’t match any of the log levels.

Trait Implementations

impl Debug for ParseLevelError[src]

impl Display for ParseLevelError[src]

impl PartialEq<ParseLevelError> for ParseLevelError[src]

impl StructuralPartialEq for ParseLevelError[src]

Auto Trait Implementations

Blanket Implementations

impl<T> Any for T where
    T: 'static + ?Sized, [src]

impl<T> Borrow<T> for T where
    T: ?Sized, [src]

impl<T> BorrowMut<T> for T where
    T: ?Sized, [src]

impl<T> From<T> for T[src]

impl<T, U> Into<U> for T where
    U: From<T>, [src]

impl<T, U> TryFrom<U> for T where
    U: Into<T>, [src]

type Error = Infallible

The type returned in the event of a conversion error.

-

impl<T, U> TryInto<U> for T where
    U: TryFrom<T>, [src]

type Error = <U as TryFrom<T>>::Error

The type returned in the event of a conversion error.

-
\ No newline at end of file +

impl StructuralPartialEq for ParseLevelError[src]

Auto Trait Implementations

Blanket Implementations

impl<T> Any for T where
    T: 'static + ?Sized, [src]

impl<T> Borrow<T> for T where
    T: ?Sized, [src]

impl<T> BorrowMut<T> for T where
    T: ?Sized, [src]

impl<T> From<T> for T[src]

impl<T, U> Into<U> for T where
    U: From<T>, [src]

impl<T, U> TryFrom<U> for T where
    U: Into<T>, [src]

type Error = Infallible

The type returned in the event of a conversion error.

+

impl<T, U> TryInto<U> for T where
    U: TryFrom<T>, [src]

type Error = <U as TryFrom<T>>::Error

The type returned in the event of a conversion error.

+
+ \ No newline at end of file diff --git a/log/struct.Record.html b/log/struct.Record.html index 1d995f9..4e6e9ea 100644 --- a/log/struct.Record.html +++ b/log/struct.Record.html @@ -1,5 +1,5 @@ -log::Record - Rust

[−][src]Struct log::Record

pub struct Record<'a> { /* fields omitted */ }

The "payload" of a log message.

+log::Record - Rust

Struct log::Record[−][src]

pub struct Record<'a> { /* fields omitted */ }

The “payload” of a log message.

Use

Record structures are passed as parameters to the log method of the Log trait. Logger implementors manipulate these @@ -43,15 +43,16 @@ module path, and message of any Record that is passed to it.

pub fn file_static(&self) -> Option<&'static str>[src]

The module path of the message, if it is a 'static string.

pub fn line(&self) -> Option<u32>[src]

The line containing the message.

Trait Implementations

impl<'a> Clone for Record<'a>[src]

impl<'a> Debug for Record<'a>[src]

Auto Trait Implementations

impl<'a> !Send for Record<'a>[src]

impl<'a> !Sync for Record<'a>[src]

impl<'a> Unpin for Record<'a>[src]

Blanket Implementations

impl<T> Any for T where
    T: 'static + ?Sized, [src]

impl<T> Borrow<T> for T where
    T: ?Sized, [src]

impl<T> BorrowMut<T> for T where
    T: ?Sized, [src]

impl<T> From<T> for T[src]

impl<T, U> Into<U> for T where
    U: From<T>, [src]

impl<T, U> TryFrom<U> for T where
    U: Into<T>, [src]

type Error = Infallible

The type returned in the event of a conversion error.

-

impl<T, U> TryInto<U> for T where
    U: TryFrom<T>, [src]

type Error = <U as TryFrom<T>>::Error

The type returned in the event of a conversion error.

-
\ No newline at end of file +

Auto Trait Implementations

impl<'a> !Send for Record<'a>

impl<'a> !Sync for Record<'a>

impl<'a> Unpin for Record<'a>

Blanket Implementations

impl<T> Any for T where
    T: 'static + ?Sized, [src]

impl<T> Borrow<T> for T where
    T: ?Sized, [src]

impl<T> BorrowMut<T> for T where
    T: ?Sized, [src]

impl<T> From<T> for T[src]

impl<T, U> Into<U> for T where
    U: From<T>, [src]

impl<T, U> TryFrom<U> for T where
    U: Into<T>, [src]

type Error = Infallible

The type returned in the event of a conversion error.

+

impl<T, U> TryInto<U> for T where
    U: TryFrom<T>, [src]

type Error = <U as TryFrom<T>>::Error

The type returned in the event of a conversion error.

+
+ \ No newline at end of file diff --git a/log/struct.RecordBuilder.html b/log/struct.RecordBuilder.html index 90a394e..a631a89 100644 --- a/log/struct.RecordBuilder.html +++ b/log/struct.RecordBuilder.html @@ -1,6 +1,6 @@ -log::RecordBuilder - Rust

[−][src]Struct log::RecordBuilder

pub struct RecordBuilder<'a> { /* fields omitted */ }

Builder for Record.

-

Typically should only be used by log library creators or for testing and "shim loggers". +log::RecordBuilder - Rust

Struct log::RecordBuilder[−][src]

pub struct RecordBuilder<'a> { /* fields omitted */ }

Builder for Record.

+

Typically should only be used by log library creators or for testing and “shim loggers”. The RecordBuilder can set the different parameters of Record object, and returns the created object when build is called.

Examples

@@ -52,13 +52,14 @@ the created object when build is called.

pub fn line(&mut self, line: Option<u32>) -> &mut RecordBuilder<'a>[src]

Set line

pub fn build(&self) -> Record<'a>[src]

Invoke the builder and return a Record

Trait Implementations

impl<'a> Debug for RecordBuilder<'a>[src]

Auto Trait Implementations

impl<'a> !Send for RecordBuilder<'a>[src]

impl<'a> !Sync for RecordBuilder<'a>[src]

impl<'a> Unpin for RecordBuilder<'a>[src]

Blanket Implementations

impl<T> Any for T where
    T: 'static + ?Sized, [src]

impl<T> Borrow<T> for T where
    T: ?Sized, [src]

impl<T> BorrowMut<T> for T where
    T: ?Sized, [src]

impl<T> From<T> for T[src]

impl<T, U> Into<U> for T where
    U: From<T>, [src]

impl<T, U> TryFrom<U> for T where
    U: Into<T>, [src]

type Error = Infallible

The type returned in the event of a conversion error.

-

impl<T, U> TryInto<U> for T where
    U: TryFrom<T>, [src]

type Error = <U as TryFrom<T>>::Error

The type returned in the event of a conversion error.

-
\ No newline at end of file +

Auto Trait Implementations

impl<'a> !Send for RecordBuilder<'a>

impl<'a> !Sync for RecordBuilder<'a>

impl<'a> Unpin for RecordBuilder<'a>

Blanket Implementations

impl<T> Any for T where
    T: 'static + ?Sized, [src]

impl<T> Borrow<T> for T where
    T: ?Sized, [src]

impl<T> BorrowMut<T> for T where
    T: ?Sized, [src]

impl<T> From<T> for T[src]

impl<T, U> Into<U> for T where
    U: From<T>, [src]

impl<T, U> TryFrom<U> for T where
    U: Into<T>, [src]

type Error = Infallible

The type returned in the event of a conversion error.

+

impl<T, U> TryInto<U> for T where
    U: TryFrom<T>, [src]

type Error = <U as TryFrom<T>>::Error

The type returned in the event of a conversion error.

+
+ \ No newline at end of file diff --git a/log/struct.SetLoggerError.html b/log/struct.SetLoggerError.html index ef28a5c..7629706 100644 --- a/log/struct.SetLoggerError.html +++ b/log/struct.SetLoggerError.html @@ -1,14 +1,15 @@ -log::SetLoggerError - Rust

[−][src]Struct log::SetLoggerError

pub struct SetLoggerError(_);

The type returned by set_logger if set_logger has already been called.

+log::SetLoggerError - Rust

Struct log::SetLoggerError[−][src]

pub struct SetLoggerError(_);

The type returned by set_logger if set_logger has already been called.

Trait Implementations

impl Debug for SetLoggerError[src]

impl Display for SetLoggerError[src]

Auto Trait Implementations

Blanket Implementations

impl<T> Any for T where
    T: 'static + ?Sized, [src]

impl<T> Borrow<T> for T where
    T: ?Sized, [src]

impl<T> BorrowMut<T> for T where
    T: ?Sized, [src]

impl<T> From<T> for T[src]

impl<T, U> Into<U> for T where
    U: From<T>, [src]

impl<T, U> TryFrom<U> for T where
    U: Into<T>, [src]

type Error = Infallible

The type returned in the event of a conversion error.

-

impl<T, U> TryInto<U> for T where
    U: TryFrom<T>, [src]

type Error = <U as TryFrom<T>>::Error

The type returned in the event of a conversion error.

-
\ No newline at end of file +

Auto Trait Implementations

Blanket Implementations

impl<T> Any for T where
    T: 'static + ?Sized, [src]

impl<T> Borrow<T> for T where
    T: ?Sized, [src]

impl<T> BorrowMut<T> for T where
    T: ?Sized, [src]

impl<T> From<T> for T[src]

impl<T, U> Into<U> for T where
    U: From<T>, [src]

impl<T, U> TryFrom<U> for T where
    U: Into<T>, [src]

type Error = Infallible

The type returned in the event of a conversion error.

+

impl<T, U> TryInto<U> for T where
    U: TryFrom<T>, [src]

type Error = <U as TryFrom<T>>::Error

The type returned in the event of a conversion error.

+
+ \ No newline at end of file diff --git a/log/trait.Log.html b/log/trait.Log.html index 325d2f8..beea967 100644 --- a/log/trait.Log.html +++ b/log/trait.Log.html @@ -1,5 +1,5 @@ -log::Log - Rust

[−][src]Trait log::Log

pub trait Log: Sync + Send {
+log::Log - Rust
Trait log::Log[−][src]
pub trait Log: Sync + Send {
     fn enabled(&self, metadata: &Metadata<'_>) -> bool;
 
    fn log(&self, record: &Record<'_>);
 
    fn flush(&self);
@@ -14,4 +14,5 @@ discarded anyway.

 Implementations of log should perform all necessary filtering
 internally.

 
fn flush(&self)[src]
Flushes any buffered records.

-
Loading content...

Implementors

Loading content...
\ No newline at end of file +Loading content...

Implementors

Loading content...
+ \ No newline at end of file diff --git a/main.js b/main.js index 69ba690..c861494 100644 --- a/main.js +++ b/main.js @@ -1,11 +1,11 @@ -if(!String.prototype.startsWith){String.prototype.startsWith=function(searchString,position){position=position||0;return this.indexOf(searchString,position)===position}}if(!String.prototype.endsWith){String.prototype.endsWith=function(suffix,length){var l=length||this.length;return this.indexOf(suffix,l-suffix.length)!==-1}}if(!DOMTokenList.prototype.add){DOMTokenList.prototype.add=function(className){if(className&&!hasClass(this,className)){if(this.className&&this.className.length>0){this.className+=" "+className}else{this.className=className}}}}if(!DOMTokenList.prototype.remove){DOMTokenList.prototype.remove=function(className){if(className&&this.className){this.className=(" "+this.className+" ").replace(" "+className+" "," ").trim()}}}function getVirtualKey(ev){if("key"in ev&&typeof ev.key!="undefined"){return ev.key}var c=ev.charCode||ev.keyCode;if(c==27){return"Escape"}return String.fromCharCode(c)}function getSearchInput(){return document.getElementsByClassName("search-input")[0]}function getSearchElement(){return document.getElementById("search")}function getThemesElement(){return document.getElementById("theme-choices")}function getThemePickerElement(){return document.getElementById("theme-picker")}function focusSearchBar(){getSearchInput().focus()}function defocusSearchBar(){getSearchInput().blur()}(function(){"use strict";var itemTypes=["mod","externcrate","import","struct","enum","fn","type","static","trait","impl","tymethod","method","structfield","variant","macro","primitive","associatedtype","constant","associatedconstant","union","foreigntype","keyword","existential","attr","derive","traitalias"];var disableShortcuts=getSettingValue("disable-shortcuts")==="true";var search_input=getSearchInput();var searchTimeout=null;var toggleAllDocsId="toggle-all-docs";var currentTab=0;var mouseMovedAfterSearch=true;var titleBeforeSearch=document.title;var searchTitle=null;function clearInputTimeout(){if(searchTimeout!==null){clearTimeout(searchTimeout);searchTimeout=null}}function getPageId(){if(window.location.hash){var tmp=window.location.hash.replace(/^#/,"");if(tmp.length>0){return tmp}}return null}function showSidebar(){var elems=document.getElementsByClassName("sidebar-elems")[0];if(elems){addClass(elems,"show-it")}var sidebar=document.getElementsByClassName("sidebar")[0];if(sidebar){addClass(sidebar,"mobile");var filler=document.getElementById("sidebar-filler");if(!filler){var div=document.createElement("div");div.id="sidebar-filler";sidebar.appendChild(div)}}}function hideSidebar(){var elems=document.getElementsByClassName("sidebar-elems")[0];if(elems){removeClass(elems,"show-it")}var sidebar=document.getElementsByClassName("sidebar")[0];removeClass(sidebar,"mobile");var filler=document.getElementById("sidebar-filler");if(filler){filler.remove()}document.getElementsByTagName("body")[0].style.marginTop=""}function showSearchResults(search){if(search===null||typeof search==='undefined'){search=getSearchElement()}addClass(main,"hidden");removeClass(search,"hidden");mouseMovedAfterSearch=false;document.title=searchTitle}function hideSearchResults(search){if(search===null||typeof search==='undefined'){search=getSearchElement()}addClass(search,"hidden");removeClass(main,"hidden");document.title=titleBeforeSearch}var TY_PRIMITIVE=itemTypes.indexOf("primitive");var TY_KEYWORD=itemTypes.indexOf("keyword");function getQueryStringParams(){var params={};window.location.search.substring(1).split("&").map(function(s){var pair=s.split("=");params[decodeURIComponent(pair[0])]=typeof pair[1]==="undefined"?null:decodeURIComponent(pair[1])});return params}function browserSupportsHistoryApi(){return window.history&&typeof window.history.pushState==="function"}function isHidden(elem){return elem.offsetHeight===0}var main=document.getElementById("main");var savedHash="";function handleHashes(ev){var elem;var search=getSearchElement();if(ev!==null&&search&&!hasClass(search,"hidden")&&ev.newURL){hideSearchResults(search);var hash=ev.newURL.slice(ev.newURL.indexOf("#")+1);if(browserSupportsHistoryApi()){history.replaceState(hash,"","?search=#"+hash)}elem=document.getElementById(hash);if(elem){elem.scrollIntoView()}}if(savedHash!==window.location.hash){savedHash=window.location.hash;if(savedHash.length===0){return}elem=document.getElementById(savedHash.slice(1));if(!elem||!isHidden(elem)){return}var parent=elem.parentNode;if(parent&&hasClass(parent,"impl-items")){onEachLazy(parent.getElementsByClassName("collapsed"),function(e){if(e.parentNode===parent){e.click();return true}});if(isHidden(elem)){if(hasClass(parent.lastElementChild,"collapse-toggle")){parent.lastElementChild.click()}}}}}function highlightSourceLines(match,ev){if(typeof match==="undefined"){hideSidebar();match=window.location.hash.match(/^#?(\d+)(?:-(\d+))?$/)}if(!match){return}var from=parseInt(match[1],10);var to=from;if(typeof match[2]!=="undefined"){to=parseInt(match[2],10)}if(to0){collapseDocs(collapses[0],"show")}}}}function getHelpElement(){buildHelperPopup();return document.getElementById("help")}function displayHelp(display,ev,help){help=help?help:getHelpElement();if(display===true){if(hasClass(help,"hidden")){ev.preventDefault();removeClass(help,"hidden");addClass(document.body,"blur")}}else if(hasClass(help,"hidden")===false){ev.preventDefault();addClass(help,"hidden");removeClass(document.body,"blur")}}function handleEscape(ev){var help=getHelpElement();var search=getSearchElement();if(hasClass(help,"hidden")===false){displayHelp(false,ev,help)}else if(hasClass(search,"hidden")===false){clearInputTimeout();ev.preventDefault();hideSearchResults(search)}defocusSearchBar();hideThemeButtonState()}function handleShortcut(ev){if(ev.ctrlKey||ev.altKey||ev.metaKey||disableShortcuts===true){return}if(document.activeElement.tagName==="INPUT"){switch(getVirtualKey(ev)){case"Escape":handleEscape(ev);break}}else{switch(getVirtualKey(ev)){case"Escape":handleEscape(ev);break;case"s":case"S":displayHelp(false,ev);ev.preventDefault();focusSearchBar();break;case"+":case"-":ev.preventDefault();toggleAllDocs();break;case"?":displayHelp(true,ev);break;case"t":case"T":displayHelp(false,ev);ev.preventDefault();var themePicker=getThemePickerElement();themePicker.click();themePicker.focus();break;default:var themePicker=getThemePickerElement();if(themePicker.parentNode.contains(ev.target)){handleThemeKeyDown(ev)}}}}function handleThemeKeyDown(ev){var active=document.activeElement;var themes=getThemesElement();switch(getVirtualKey(ev)){case"ArrowUp":ev.preventDefault();if(active.previousElementSibling&&ev.target.id!=="theme-picker"){active.previousElementSibling.focus()}else{showThemeButtonState();themes.lastElementChild.focus()}break;case"ArrowDown":ev.preventDefault();if(active.nextElementSibling&&ev.target.id!=="theme-picker"){active.nextElementSibling.focus()}else{showThemeButtonState();themes.firstElementChild.focus()}break;case"Enter":case"Return":case"Space":if(ev.target.id==="theme-picker"&&themes.style.display==="none"){ev.preventDefault();showThemeButtonState();themes.firstElementChild.focus()}break;case"Home":ev.preventDefault();themes.firstElementChild.focus();break;case"End":ev.preventDefault();themes.lastElementChild.focus();break}}function findParentElement(elem,tagName){do{if(elem&&elem.tagName===tagName){return elem}elem=elem.parentNode}while(elem);return null}document.addEventListener("keypress",handleShortcut);document.addEventListener("keydown",handleShortcut);function resetMouseMoved(ev){mouseMovedAfterSearch=true}document.addEventListener("mousemove",resetMouseMoved);var handleSourceHighlight=(function(){var prev_line_id=0;var set_fragment=function(name){var x=window.scrollX,y=window.scrollY;if(browserSupportsHistoryApi()){history.replaceState(null,null,"#"+name);highlightSourceLines()}else{location.replace("#"+name)}window.scrollTo(x,y)};return function(ev){var cur_line_id=parseInt(ev.target.id,10);ev.preventDefault();if(ev.shiftKey&&prev_line_id){if(prev_line_id>cur_line_id){var tmp=prev_line_id;prev_line_id=cur_line_id;cur_line_id=tmp}set_fragment(prev_line_id+"-"+cur_line_id)}else{prev_line_id=cur_line_id;set_fragment(cur_line_id)}}}());document.addEventListener("click",function(ev){if(hasClass(ev.target,"help-button")){displayHelp(true,ev)}else if(hasClass(ev.target,"collapse-toggle")){collapseDocs(ev.target,"toggle")}else if(hasClass(ev.target.parentNode,"collapse-toggle")){collapseDocs(ev.target.parentNode,"toggle")}else if(ev.target.tagName==="SPAN"&&hasClass(ev.target.parentNode,"line-numbers")){handleSourceHighlight(ev)}else if(hasClass(getHelpElement(),"hidden")===false){var help=getHelpElement();var is_inside_help_popup=ev.target!==help&&help.contains(ev.target);if(is_inside_help_popup===false){addClass(help,"hidden");removeClass(document.body,"blur")}}else{var a=findParentElement(ev.target,"A");if(a&&a.hash){expandSection(a.hash.replace(/^#/,""))}}});(function(){var x=document.getElementsByClassName("version-selector");if(x.length>0){x[0].onchange=function(){var i,match,url=document.location.href,stripped="",len=rootPath.match(/\.\.\//g).length+1;for(i=0;i-1){var obj=searchIndex[results[i].id];obj.lev=results[i].lev;if(isType!==true||obj.type){var res=buildHrefAndPath(obj);obj.displayPath=pathSplitter(res[0]);obj.fullPath=obj.displayPath+obj.name;obj.fullPath+="|"+obj.ty;obj.href=res[1];out.push(obj);if(out.length>=MAX_RESULTS){break}}}}return out}function sortResults(results,isType){var ar=[];for(var entry in results){if(hasOwnProperty(results,entry)){ar.push(results[entry])}}results=ar;var i;var nresults=results.length;for(i=0;ib?+1:-1)}a=(aaa.index<0);b=(bbb.index<0);if(a!==b){return a-b}a=aaa.index;b=bbb.index;if(a!==b){return a-b}if((aaa.item.ty===TY_PRIMITIVE&&bbb.item.ty!==TY_KEYWORD)||(aaa.item.ty===TY_KEYWORD&&bbb.item.ty!==TY_PRIMITIVE)){return-1}if((bbb.item.ty===TY_PRIMITIVE&&aaa.item.ty!==TY_PRIMITIVE)||(bbb.item.ty===TY_KEYWORD&&aaa.item.ty!==TY_KEYWORD)){return 1}a=(aaa.item.desc==="");b=(bbb.item.desc==="");if(a!==b){return a-b}a=aaa.item.ty;b=bbb.item.ty;if(a!==b){return a-b}a=aaa.item.path;b=bbb.item.path;if(a!==b){return(a>b?+1:-1)}return 0});var length=results.length;for(i=0;i"));return{name:val.substring(0,val.indexOf("<")),generics:values.split(/\s*,\s*/),}}return{name:val,generics:[],}}function getObjectFromId(id){if(typeof id==="number"){return searchIndex[id]}return{'name':id}}function checkGenerics(obj,val){var lev_distance=MAX_LEV_DISTANCE+1;if(val.generics.length>0){if(obj.length>GENERICS_DATA&&obj[GENERICS_DATA].length>=val.generics.length){var elems=obj[GENERICS_DATA].slice(0);var total=0;var done=0;var vlength=val.generics.length;for(var y=0;yGENERICS_DATA&&obj[GENERICS_DATA].length>=val.generics.length){var elems=obj[GENERICS_DATA].slice(0);var allFound=true;for(var y=0;allFound===true&&yGENERICS_DATA&&obj[GENERICS_DATA].length!==0){var tmp_lev=checkGenerics(obj,val);if(tmp_lev<=MAX_LEV_DISTANCE){return tmp_lev}}else{return 0}}if(literalSearch===true){if(obj.length>GENERICS_DATA&&obj[GENERICS_DATA].length>0){var length=obj[GENERICS_DATA].length;for(x=0;xGENERICS_DATA&&obj[GENERICS_DATA].length>0){var olength=obj[GENERICS_DATA].length;for(x=0;x0){var length=obj.type[INPUTS_DATA].length;for(var i=0;iOUTPUT_DATA){var ret=obj.type[OUTPUT_DATA];if(typeof ret[0]==="string"){ret=[ret]}for(var x=0;xlength){return MAX_LEV_DISTANCE+1}for(var i=0;ilength){break}var lev_total=0;var aborted=false;for(var x=0;xMAX_LEV_DISTANCE){aborted=true;break}lev_total+=lev}if(aborted===false){ret_lev=Math.min(ret_lev,Math.round(lev_total/clength))}}return ret_lev}function typePassesFilter(filter,type){if(filter<=NO_TYPE_FILTER)return true;if(filter===type)return true;var name=itemTypes[type];switch(itemTypes[filter]){case"constant":return name==="associatedconstant";case"fn":return name==="method"||name==="tymethod";case"type":return name==="primitive"||name==="associatedtype";case"trait":return name==="traitalias"}return false}function generateId(ty){if(ty.parent&&ty.parent.name){return itemTypes[ty.ty]+ty.path+ty.parent.name+ty.name}return itemTypes[ty.ty]+ty.path+ty.name}function createAliasFromItem(item){return{crate:item.crate,name:item.name,path:item.path,desc:item.desc,ty:item.ty,parent:item.parent,type:item.type,is_alias:true,}}function handleAliases(ret,query,filterCrates){var aliases=[];var crateAliases=[];var i;if(filterCrates!==undefined){if(ALIASES[filterCrates]&&ALIASES[filterCrates][query.search]){for(i=0;iMAX_RESULTS){ret.others.pop()}};onEach(aliases,pushFunc);onEach(crateAliases,pushFunc)}var nSearchWords=searchWords.length;var i;var ty;var fullId;var returned;var in_args;if((val.charAt(0)==="\""||val.charAt(0)==="'")&&val.charAt(val.length-1)===val.charAt(0)){val=extractGenerics(val.substr(1,val.length-2));for(i=0;i")>-1){var trimmer=function(s){return s.trim()};var parts=val.split("->").map(trimmer);var input=parts[0];var inputs=input.split(",").map(trimmer).sort();for(i=0;i1?paths.length-1:1);var lev;for(j=0;j1){lev=checkPath(contains,paths[paths.length-1],ty);if(lev>MAX_LEV_DISTANCE){continue}else if(lev>0){lev_add=lev/10}}returned=MAX_LEV_DISTANCE+1;in_args=MAX_LEV_DISTANCE+1;var index=-1;lev=MAX_LEV_DISTANCE+1;fullId=generateId(ty);if(searchWords[j].indexOf(split[i])>-1||searchWords[j].indexOf(val)>-1||searchWords[j].replace(/_/g,"").indexOf(val)>-1){if(typePassesFilter(typeFilter,ty.ty)&&results[fullId]===undefined){index=searchWords[j].replace(/_/g,"").indexOf(val)}}if((lev=levenshtein(searchWords[j],val))<=MAX_LEV_DISTANCE){if(typePassesFilter(typeFilter,ty.ty)===false){lev=MAX_LEV_DISTANCE+1}else{lev+=1}}in_args=findArg(ty,valGenerics,false,typeFilter);returned=checkReturned(ty,valGenerics,false,typeFilter);lev+=lev_add;if(lev>0&&val.length>3&&searchWords[j].indexOf(val)>-1){if(val.length<6){lev-=1}else{lev=0}}if(in_args<=MAX_LEV_DISTANCE){if(results_in_args[fullId]===undefined){results_in_args[fullId]={id:j,index:index,lev:in_args,}}results_in_args[fullId].lev=Math.min(results_in_args[fullId].lev,in_args)}if(returned<=MAX_LEV_DISTANCE){if(results_returned[fullId]===undefined){results_returned[fullId]={id:j,index:index,lev:returned,}}results_returned[fullId].lev=Math.min(results_returned[fullId].lev,returned)}if(index!==-1||lev<=MAX_LEV_DISTANCE){if(index!==-1&&paths.length<2){lev=0}if(results[fullId]===undefined){results[fullId]={id:j,index:index,lev:lev,}}results[fullId].lev=Math.min(results[fullId].lev,lev)}}}var ret={"in_args":sortResults(results_in_args,true),"returned":sortResults(results_returned,true),"others":sortResults(results),};handleAliases(ret,query,filterCrates);return ret}function validateResult(name,path,keys,parent){for(var i=0;i-1||path.indexOf(keys[i])>-1||(parent!==undefined&&parent.name!==undefined&&parent.name.toLowerCase().indexOf(keys[i])>-1)||levenshtein(name,keys[i])<=MAX_LEV_DISTANCE)){return false}}return true}function getQuery(raw){var matches,type,query;query=raw;matches=query.match(/^(fn|mod|struct|enum|trait|type|const|macro)\s*:\s*/i);if(matches){type=matches[1].replace(/^const$/,"constant");query=query.substring(matches[0].length)}return{raw:raw,query:query,type:type,id:query+type}}function initSearchNav(){var hoverTimeout;var click_func=function(e){var el=e.target;while(el.tagName!=="TR"){el=el.parentNode}var dst=e.target.getElementsByTagName("a");if(dst.length<1){return}dst=dst[0];if(window.location.pathname===dst.pathname){hideSearchResults();document.location.href=dst.href}};var mouseover_func=function(e){if(mouseMovedAfterSearch){var el=e.target;while(el.tagName!=="TR"){el=el.parentNode}clearTimeout(hoverTimeout);hoverTimeout=setTimeout(function(){onEachLazy(document.getElementsByClassName("search-results"),function(e){onEachLazy(e.getElementsByClassName("result"),function(i_e){removeClass(i_e,"highlighted")})});addClass(el,"highlighted")},20)}};onEachLazy(document.getElementsByClassName("search-results"),function(e){onEachLazy(e.getElementsByClassName("result"),function(i_e){i_e.onclick=click_func;i_e.onmouseover=mouseover_func})});search_input.onkeydown=function(e){var actives=[[],[],[]];var current=0;onEachLazy(document.getElementById("results").childNodes,function(e){onEachLazy(e.getElementsByClassName("highlighted"),function(h_e){actives[current].push(h_e)});current+=1});if(e.which===38){if(e.ctrlKey){printTab(currentTab>0?currentTab-1:2)}else{if(!actives[currentTab].length||!actives[currentTab][0].previousElementSibling){return}addClass(actives[currentTab][0].previousElementSibling,"highlighted");removeClass(actives[currentTab][0],"highlighted")}e.preventDefault()}else if(e.which===40){if(e.ctrlKey){printTab(currentTab>1?0:currentTab+1)}else if(!actives[currentTab].length){var results=document.getElementById("results").childNodes;if(results.length>0){var res=results[currentTab].getElementsByClassName("result");if(res.length>0){addClass(res[0],"highlighted")}}}else if(actives[currentTab][0].nextElementSibling){addClass(actives[currentTab][0].nextElementSibling,"highlighted");removeClass(actives[currentTab][0],"highlighted")}e.preventDefault()}else if(e.which===13){if(actives[currentTab].length){document.location.href=actives[currentTab][0].getElementsByTagName("a")[0].href}}else if(e.which===16){}else if(actives[currentTab].length>0){removeClass(actives[currentTab][0],"highlighted")}}}function buildHrefAndPath(item){var displayPath;var href;var type=itemTypes[item.ty];var name=item.name;var path=item.path;if(type==="mod"){displayPath=path+"::";href=rootPath+path.replace(/::/g,"/")+"/"+name+"/index.html"}else if(type==="primitive"||type==="keyword"){displayPath="";href=rootPath+path.replace(/::/g,"/")+"/"+type+"."+name+".html"}else if(type==="externcrate"){displayPath="";href=rootPath+name+"/index.html"}else if(item.parent!==undefined){var myparent=item.parent;var anchor="#"+type+"."+name;var parentType=itemTypes[myparent.ty];var pageType=parentType;var pageName=myparent.name;if(parentType==="primitive"){displayPath=myparent.name+"::"}else if(type==="structfield"&&parentType==="variant"){var splitPath=item.path.split("::");var enumName=splitPath.pop();path=splitPath.join("::");displayPath=path+"::"+enumName+"::"+myparent.name+"::";anchor="#variant."+myparent.name+".field."+name;pageType="enum";pageName=enumName}else{displayPath=path+"::"+myparent.name+"::"}href=rootPath+path.replace(/::/g,"/")+"/"+pageType+"."+pageName+".html"+anchor}else{displayPath=item.path+"::";href=rootPath+item.path.replace(/::/g,"/")+"/"+type+"."+name+".html"}return[displayPath,href]}function escape(content){var h1=document.createElement("h1");h1.textContent=content;return h1.innerHTML}function pathSplitter(path){var tmp=""+path.replace(/::/g,"::");if(tmp.endsWith("")){return tmp.slice(0,tmp.length-6)}return tmp}function addTab(array,query,display){var extraStyle="";if(display===false){extraStyle=" style=\"display: none;\""}var output="";var duplicates={};var length=0;if(array.length>0){output="";array.forEach(function(item){var name,type;name=item.name;type=itemTypes[item.ty];if(item.is_alias!==true){if(duplicates[item.fullPath]){return}duplicates[item.fullPath]=true}length+=1;output+=""});output+="
"+""+(item.is_alias===true?(""+item.alias+"  - see "):"")+item.displayPath+""+name+""+""+""+item.desc+" 
"}else{output="
No results :(
"+"Try on DuckDuckGo?

"+"Or try looking in one of these:
"}return[output,length]}function makeTabHeader(tabNb,text,nbElems){if(currentTab===tabNb){return""}return""}function showResults(results){var search=getSearchElement();if(results.others.length===1&&getSettingValue("go-to-only-result")==="true"&&(!search.firstChild||search.firstChild.innerText!==getSearchLoadingText())){var elem=document.createElement("a");elem.href=results.others[0].href;elem.style.display="none";document.body.appendChild(elem);elem.click();return}var query=getQuery(search_input.value);currentResults=query.id;var ret_others=addTab(results.others,query);var ret_in_args=addTab(results.in_args,query,false);var ret_returned=addTab(results.returned,query,false);var output="

Results for "+escape(query.query)+(query.type?" (type: "+escape(query.type)+")":"")+"

"+"
"+makeTabHeader(0,"In Names",ret_others[1])+makeTabHeader(1,"In Parameters",ret_in_args[1])+makeTabHeader(2,"In Return Types",ret_returned[1])+"
"+ret_others[0]+ret_in_args[0]+ret_returned[0]+"
";search.innerHTML=output;showSearchResults(search);var tds=search.getElementsByTagName("td");var td_width=0;if(tds.length>0){td_width=tds[0].offsetWidth}var width=search.offsetWidth-40-td_width;onEachLazy(search.getElementsByClassName("desc"),function(e){e.style.width=width+"px"});initSearchNav();var elems=document.getElementById("titles").childNodes;elems[0].onclick=function(){printTab(0)};elems[1].onclick=function(){printTab(1)};elems[2].onclick=function(){printTab(2)};printTab(currentTab)}function execSearch(query,searchWords,filterCrates){function getSmallest(arrays,positions,notDuplicates){var start=null;for(var it=0;itpositions[it]&&(start===null||start>arrays[it][positions[it]].lev)&&!notDuplicates[arrays[it][positions[it]].fullPath]){start=arrays[it][positions[it]].lev}}return start}function mergeArrays(arrays){var ret=[];var positions=[];var notDuplicates={};for(var x=0;xpositions[x]&&arrays[x][positions[x]].lev===smallest&&!notDuplicates[arrays[x][positions[x]].fullPath]){ret.push(arrays[x][positions[x]]);notDuplicates[arrays[x][positions[x]].fullPath]=true;positions[x]+=1}}}return ret}var queries=query.raw.split(",");var results={"in_args":[],"returned":[],"others":[],};for(var i=0;i1){return{"in_args":mergeArrays(results.in_args),"returned":mergeArrays(results.returned),"others":mergeArrays(results.others),}}return{"in_args":results.in_args[0],"returned":results.returned[0],"others":results.others[0],}}function getFilterCrates(){var elem=document.getElementById("crate-search");if(elem&&elem.value!=="All crates"&&hasOwnProperty(rawSearchIndex,elem.value)){return elem.value}return undefined}function search(e,forced){var params=getQueryStringParams();var query=getQuery(search_input.value.trim());if(e){e.preventDefault()}if(query.query.length===0){return}if(forced!==true&&query.id===currentResults){if(query.query.length>0){putBackSearch(search_input)}return}searchTitle="Results for "+query.query+" - Rust";if(browserSupportsHistoryApi()){if(!history.state&&!params.search){history.pushState(query,"","?search="+encodeURIComponent(query.raw))}else{history.replaceState(query,"","?search="+encodeURIComponent(query.raw))}}var filterCrates=getFilterCrates();showResults(execSearch(query,index,filterCrates))}function buildIndex(rawSearchIndex){searchIndex=[];var searchWords=[];var i;var currentIndex=0;for(var crate in rawSearchIndex){if(!hasOwnProperty(rawSearchIndex,crate)){continue}var crateSize=0;searchWords.push(crate);searchIndex.push({crate:crate,ty:1,name:crate,path:"",desc:rawSearchIndex[crate].doc,type:null,});currentIndex+=1;var items=rawSearchIndex[crate].i;var paths=rawSearchIndex[crate].p;var aliases=rawSearchIndex[crate].a;var len=paths.length;for(i=0;i0){search_input.value=params.search;search(e)}else{search_input.value="";hideSearchResults()}})}search()}index=buildIndex(rawSearchIndex);startSearch();if(rootPath==="../"||rootPath==="./"){var sidebar=document.getElementsByClassName("sidebar-elems")[0];if(sidebar){var div=document.createElement("div");div.className="block crate";div.innerHTML="

Crates

";var ul=document.createElement("ul");div.appendChild(ul);var crates=[];for(var crate in rawSearchIndex){if(!hasOwnProperty(rawSearchIndex,crate)){continue}crates.push(crate)}crates.sort();for(var i=0;i','`').replace('','`');return x.innerText}window.initSidebarItems=function(items){var sidebar=document.getElementsByClassName("sidebar-elems")[0];var current=window.sidebarCurrent;function block(shortty,longty){var filtered=items[shortty];if(!filtered){return}var div=document.createElement("div");div.className="block "+shortty;var h3=document.createElement("h3");h3.textContent=longty;div.appendChild(h3);var ul=document.createElement("ul");var length=filtered.length;for(var i=0;i"+""+"
"+code.outerHTML+"
";list.appendChild(display)}}};if(window.pending_implementors){window.register_implementors(window.pending_implementors)}function labelForToggleButton(sectionIsCollapsed){if(sectionIsCollapsed){return"+"}return"\u2212"}function onEveryMatchingChild(elem,className,func){if(elem&&className&&func){var length=elem.childNodes.length;var nodes=elem.childNodes;for(var i=0;i"+labelForToggleButton(sectionIsCollapsed)+"]";return toggle}function createToggle(toggle,otherMessage,fontSize,extraClass,show){var span=document.createElement("span");span.className="toggle-label";if(show){span.style.display="none"}if(!otherMessage){span.innerHTML=" Expand description"}else{span.innerHTML=otherMessage}if(fontSize){span.style.fontSize=fontSize}var mainToggle=toggle.cloneNode(true);mainToggle.appendChild(span);var wrapper=document.createElement("div");wrapper.className="toggle-wrapper";if(!show){addClass(wrapper,"collapsed");var inner=mainToggle.getElementsByClassName("inner");if(inner&&inner.length>0){inner[0].innerHTML="+"}}if(extraClass){addClass(wrapper,extraClass)}wrapper.appendChild(mainToggle);return wrapper}(function(){var toggles=document.getElementById(toggleAllDocsId);if(toggles){toggles.onclick=toggleAllDocs}var toggle=createSimpleToggle(false);var hideMethodDocs=getSettingValue("auto-hide-method-docs")==="true";var hideImplementors=getSettingValue("auto-collapse-implementors")!=="false";var pageId=getPageId();var func=function(e){var next=e.nextElementSibling;if(next&&hasClass(next,"item-info")){next=next.nextElementSibling}if(!next){return}if(hasClass(next,"docblock")){var newToggle=toggle.cloneNode(true);insertAfter(newToggle,e.childNodes[e.childNodes.length-1]);if(hideMethodDocs===true&&hasClass(e,"method")===true){collapseDocs(newToggle,"hide",pageId)}}};var funcImpl=function(e){var next=e.nextElementSibling;if(next&&hasClass(next,"item-info")){next=next.nextElementSibling}if(next&&hasClass(next,"docblock")){next=next.nextElementSibling}if(!next){return}if(hasClass(e,"impl")&&(next.getElementsByClassName("method").length>0||next.getElementsByClassName("associatedconstant").length>0)){var newToggle=toggle.cloneNode(true);insertAfter(newToggle,e.childNodes[e.childNodes.length-1]);if(hideImplementors===true&&e.parentNode.id==="implementors-list"){collapseDocs(newToggle,"hide",pageId)}}};onEachLazy(document.getElementsByClassName("method"),func);onEachLazy(document.getElementsByClassName("associatedconstant"),func);onEachLazy(document.getElementsByClassName("impl"),funcImpl);var impl_call=function(){};if(hideMethodDocs===true){impl_call=function(e,newToggle){if(e.id.match(/^impl(?:-\d+)?$/)===null){if(hasClass(e,"impl")===true){collapseDocs(newToggle,"hide",pageId)}}}}var newToggle=document.createElement("a");newToggle.href="javascript:void(0)";newToggle.className="collapse-toggle hidden-default collapsed";newToggle.innerHTML="["+labelForToggleButton(true)+"] Show hidden undocumented items";function toggleClicked(){if(hasClass(this,"collapsed")){removeClass(this,"collapsed");onEachLazy(this.parentNode.getElementsByClassName("hidden"),function(x){if(hasClass(x,"content")===false){removeClass(x,"hidden");addClass(x,"x")}},true);this.innerHTML="["+labelForToggleButton(false)+"] Hide undocumented items"}else{addClass(this,"collapsed");onEachLazy(this.parentNode.getElementsByClassName("x"),function(x){if(hasClass(x,"content")===false){addClass(x,"hidden");removeClass(x,"x")}},true);this.innerHTML="["+labelForToggleButton(true)+"] Show hidden undocumented items"}}onEachLazy(document.getElementsByClassName("impl-items"),function(e){onEachLazy(e.getElementsByClassName("associatedconstant"),func);var hiddenElems=e.getElementsByClassName("hidden");var needToggle=false;var hlength=hiddenElems.length;for(var i=0;i"+getSearchLoadingText()+"";showSearchResults(search)}var sidebar_menu=document.getElementsByClassName("sidebar-menu")[0];if(sidebar_menu){sidebar_menu.onclick=function(){var sidebar=document.getElementsByClassName("sidebar")[0];if(hasClass(sidebar,"mobile")===true){hideSidebar()}else{showSidebar()}}}if(main){onEachLazy(main.getElementsByClassName("loading-content"),function(e){e.remove()});onEachLazy(main.childNodes,function(e){if(e.tagName==="H2"||e.tagName==="H3"){var nextTagName=e.nextElementSibling.tagName;if(nextTagName=="H2"||nextTagName=="H3"){e.nextElementSibling.style.display="flex"}else{e.nextElementSibling.style.display="block"}}})}function enableSearchInput(){if(search_input){search_input.removeAttribute('disabled')}}window.addSearchOptions=function(crates){var elem=document.getElementById("crate-search");if(!elem){enableSearchInput();return}var crates_text=[];if(Object.keys(crates).length>1){for(var crate in crates){if(hasOwnProperty(crates,crate)){crates_text.push(crate)}}}crates_text.sort(function(a,b){var lower_a=a.toLowerCase();var lower_b=b.toLowerCase();if(lower_alower_b){return 1}return 0});var savedCrate=getSettingValue("saved-filter-crate");for(var i=0;ithe rustdoc book.";var container=document.createElement("div");var shortcuts=[["?","Show this help dialog"],["S","Focus the search field"],["T","Focus the theme picker menu"],["↑","Move up in search results"],["↓","Move down in search results"],["ctrl + ↑ / ↓","Switch result tab"],["⏎","Go to active search result"],["+","Expand all sections"],["-","Collapse all sections"],].map(x=>"
"+x[0].split(" ").map((y,index)=>(index&1)===0?""+y+"":y).join("")+"
"+x[1]+"
").join("");var div_shortcuts=document.createElement("div");addClass(div_shortcuts,"shortcuts");div_shortcuts.innerHTML="

Keyboard Shortcuts

"+shortcuts+"
";var infos=["Prefix searches with a type followed by a colon (e.g., fn:) to \ +if(!String.prototype.startsWith){String.prototype.startsWith=function(searchString,position){position=position||0;return this.indexOf(searchString,position)===position}}if(!String.prototype.endsWith){String.prototype.endsWith=function(suffix,length){var l=length||this.length;return this.indexOf(suffix,l-suffix.length)!==-1}}if(!DOMTokenList.prototype.add){DOMTokenList.prototype.add=function(className){if(className&&!hasClass(this,className)){if(this.className&&this.className.length>0){this.className+=" "+className}else{this.className=className}}}}if(!DOMTokenList.prototype.remove){DOMTokenList.prototype.remove=function(className){if(className&&this.className){this.className=(" "+this.className+" ").replace(" "+className+" "," ").trim()}}}(function(){var rustdocVars=document.getElementById("rustdoc-vars");if(rustdocVars){window.rootPath=rustdocVars.attributes["data-root-path"].value;window.currentCrate=rustdocVars.attributes["data-current-crate"].value;window.searchJS=rustdocVars.attributes["data-search-js"].value}var sidebarVars=document.getElementById("sidebar-vars");if(sidebarVars){window.sidebarCurrent={name:sidebarVars.attributes["data-name"].value,ty:sidebarVars.attributes["data-ty"].value,relpath:sidebarVars.attributes["data-relpath"].value,}}}());function getVirtualKey(ev){if("key"in ev&&typeof ev.key!="undefined"){return ev.key}var c=ev.charCode||ev.keyCode;if(c==27){return"Escape"}return String.fromCharCode(c)}function getSearchInput(){return document.getElementsByClassName("search-input")[0]}function getSearchElement(){return document.getElementById("search")}function getThemesElement(){return document.getElementById("theme-choices")}function getThemePickerElement(){return document.getElementById("theme-picker")}function getNakedUrl(){return window.location.href.split("?")[0].split("#")[0]}function focusSearchBar(){getSearchInput().focus()}function defocusSearchBar(){getSearchInput().blur()}(function(){"use strict";var itemTypes=["mod","externcrate","import","struct","enum","fn","type","static","trait","impl","tymethod","method","structfield","variant","macro","primitive","associatedtype","constant","associatedconstant","union","foreigntype","keyword","existential","attr","derive","traitalias"];var disableShortcuts=getSettingValue("disable-shortcuts")==="true";var search_input=getSearchInput();var searchTimeout=null;var toggleAllDocsId="toggle-all-docs";var currentTab=0;var mouseMovedAfterSearch=true;var titleBeforeSearch=document.title;var searchTitle=null;function clearInputTimeout(){if(searchTimeout!==null){clearTimeout(searchTimeout);searchTimeout=null}}function getPageId(){if(window.location.hash){var tmp=window.location.hash.replace(/^#/,"");if(tmp.length>0){return tmp}}return null}function showSidebar(){var elems=document.getElementsByClassName("sidebar-elems")[0];if(elems){addClass(elems,"show-it")}var sidebar=document.getElementsByClassName("sidebar")[0];if(sidebar){addClass(sidebar,"mobile");var filler=document.getElementById("sidebar-filler");if(!filler){var div=document.createElement("div");div.id="sidebar-filler";sidebar.appendChild(div)}}}function hideSidebar(){var elems=document.getElementsByClassName("sidebar-elems")[0];if(elems){removeClass(elems,"show-it")}var sidebar=document.getElementsByClassName("sidebar")[0];removeClass(sidebar,"mobile");var filler=document.getElementById("sidebar-filler");if(filler){filler.remove()}document.getElementsByTagName("body")[0].style.marginTop=""}function showSearchResults(search){if(search===null||typeof search==='undefined'){search=getSearchElement()}addClass(main,"hidden");removeClass(search,"hidden");mouseMovedAfterSearch=false;document.title=searchTitle}function hideSearchResults(search){if(search===null||typeof search==='undefined'){search=getSearchElement()}addClass(search,"hidden");removeClass(main,"hidden");document.title=titleBeforeSearch;if(browserSupportsHistoryApi()){history.replaceState("",window.currentCrate+" - Rust",getNakedUrl()+window.location.hash)}}var TY_PRIMITIVE=itemTypes.indexOf("primitive");var TY_KEYWORD=itemTypes.indexOf("keyword");function getQueryStringParams(){var params={};window.location.search.substring(1).split("&").map(function(s){var pair=s.split("=");params[decodeURIComponent(pair[0])]=typeof pair[1]==="undefined"?null:decodeURIComponent(pair[1])});return params}function browserSupportsHistoryApi(){return window.history&&typeof window.history.pushState==="function"}function isHidden(elem){return elem.offsetHeight===0}var main=document.getElementById("main");var savedHash="";function handleHashes(ev){var elem;var search=getSearchElement();if(ev!==null&&search&&!hasClass(search,"hidden")&&ev.newURL){hideSearchResults(search);var hash=ev.newURL.slice(ev.newURL.indexOf("#")+1);if(browserSupportsHistoryApi()){history.replaceState(hash,"",getNakedUrl()+window.location.search+"#"+hash)}elem=document.getElementById(hash);if(elem){elem.scrollIntoView()}}if(savedHash!==window.location.hash){savedHash=window.location.hash;if(savedHash.length===0){return}elem=document.getElementById(savedHash.slice(1));if(!elem||!isHidden(elem)){return}var parent=elem.parentNode;if(parent&&hasClass(parent,"impl-items")){onEachLazy(parent.getElementsByClassName("collapsed"),function(e){if(e.parentNode===parent){e.click();return true}});if(isHidden(elem)){if(hasClass(parent.lastElementChild,"collapse-toggle")){parent.lastElementChild.click()}}}}}function highlightSourceLines(match,ev){if(typeof match==="undefined"){hideSidebar();match=window.location.hash.match(/^#?(\d+)(?:-(\d+))?$/)}if(!match){return}var from=parseInt(match[1],10);var to=from;if(typeof match[2]!=="undefined"){to=parseInt(match[2],10)}if(to0){collapseDocs(collapses[0],"show")}}}}function getHelpElement(build){if(build!==false){buildHelperPopup()}return document.getElementById("help")}function displayHelp(display,ev,help){if(display===true){help=help?help:getHelpElement(true);if(hasClass(help,"hidden")){ev.preventDefault();removeClass(help,"hidden");addClass(document.body,"blur")}}else{help=help?help:getHelpElement(false);if(help&&hasClass(help,"hidden")===false){ev.preventDefault();addClass(help,"hidden");removeClass(document.body,"blur")}}}function handleEscape(ev){var help=getHelpElement(false);var search=getSearchElement();if(hasClass(help,"hidden")===false){displayHelp(false,ev,help)}else if(hasClass(search,"hidden")===false){clearInputTimeout();ev.preventDefault();hideSearchResults(search)}defocusSearchBar();hideThemeButtonState()}function handleShortcut(ev){if(ev.ctrlKey||ev.altKey||ev.metaKey||disableShortcuts===true){return}if(document.activeElement.tagName==="INPUT"){switch(getVirtualKey(ev)){case"Escape":handleEscape(ev);break}}else{switch(getVirtualKey(ev)){case"Escape":handleEscape(ev);break;case"s":case"S":displayHelp(false,ev);ev.preventDefault();focusSearchBar();break;case"+":case"-":ev.preventDefault();toggleAllDocs();break;case"?":displayHelp(true,ev);break;case"t":case"T":displayHelp(false,ev);ev.preventDefault();var themePicker=getThemePickerElement();themePicker.click();themePicker.focus();break;default:var themePicker=getThemePickerElement();if(themePicker.parentNode.contains(ev.target)){handleThemeKeyDown(ev)}}}}function handleThemeKeyDown(ev){var active=document.activeElement;var themes=getThemesElement();switch(getVirtualKey(ev)){case"ArrowUp":ev.preventDefault();if(active.previousElementSibling&&ev.target.id!=="theme-picker"){active.previousElementSibling.focus()}else{showThemeButtonState();themes.lastElementChild.focus()}break;case"ArrowDown":ev.preventDefault();if(active.nextElementSibling&&ev.target.id!=="theme-picker"){active.nextElementSibling.focus()}else{showThemeButtonState();themes.firstElementChild.focus()}break;case"Enter":case"Return":case"Space":if(ev.target.id==="theme-picker"&&themes.style.display==="none"){ev.preventDefault();showThemeButtonState();themes.firstElementChild.focus()}break;case"Home":ev.preventDefault();themes.firstElementChild.focus();break;case"End":ev.preventDefault();themes.lastElementChild.focus();break}}function findParentElement(elem,tagName){do{if(elem&&elem.tagName===tagName){return elem}elem=elem.parentNode}while(elem);return null}document.addEventListener("keypress",handleShortcut);document.addEventListener("keydown",handleShortcut);document.addEventListener("mousemove",function(){mouseMovedAfterSearch=true});var handleSourceHighlight=(function(){var prev_line_id=0;var set_fragment=function(name){var x=window.scrollX,y=window.scrollY;if(browserSupportsHistoryApi()){history.replaceState(null,null,"#"+name);highlightSourceLines()}else{location.replace("#"+name)}window.scrollTo(x,y)};return function(ev){var cur_line_id=parseInt(ev.target.id,10);ev.preventDefault();if(ev.shiftKey&&prev_line_id){if(prev_line_id>cur_line_id){var tmp=prev_line_id;prev_line_id=cur_line_id;cur_line_id=tmp}set_fragment(prev_line_id+"-"+cur_line_id)}else{prev_line_id=cur_line_id;set_fragment(cur_line_id)}}}());document.addEventListener("click",function(ev){var helpElem=getHelpElement(false);if(hasClass(ev.target,"help-button")){displayHelp(true,ev)}else if(hasClass(ev.target,"collapse-toggle")){collapseDocs(ev.target,"toggle")}else if(hasClass(ev.target.parentNode,"collapse-toggle")){collapseDocs(ev.target.parentNode,"toggle")}else if(ev.target.tagName==="SPAN"&&hasClass(ev.target.parentNode,"line-numbers")){handleSourceHighlight(ev)}else if(helpElem&&hasClass(helpElem,"hidden")===false){var is_inside_help_popup=ev.target!==helpElem&&helpElem.contains(ev.target);if(is_inside_help_popup===false){addClass(helpElem,"hidden");removeClass(document.body,"blur")}}else{var a=findParentElement(ev.target,"A");if(a&&a.hash){expandSection(a.hash.replace(/^#/,""))}}});(function(){var x=document.getElementsByClassName("version-selector");if(x.length>0){x[0].onchange=function(){var i,match,url=document.location.href,stripped="",len=window.rootPath.match(/\.\.\//g).length+1;for(i=0;i-1){var obj=searchIndex[results[i].id];obj.lev=results[i].lev;if(isType!==true||obj.type){var res=buildHrefAndPath(obj);obj.displayPath=pathSplitter(res[0]);obj.fullPath=obj.displayPath+obj.name;obj.fullPath+="|"+obj.ty;obj.href=res[1];out.push(obj);if(out.length>=MAX_RESULTS){break}}}}return out}function sortResults(results,isType){var ar=[];for(var entry in results){if(hasOwnProperty(results,entry)){ar.push(results[entry])}}results=ar;var i,len,result;for(i=0,len=results.length;ib?+1:-1)}a=(aaa.index<0);b=(bbb.index<0);if(a!==b){return a-b}a=aaa.index;b=bbb.index;if(a!==b){return a-b}if((aaa.item.ty===TY_PRIMITIVE&&bbb.item.ty!==TY_KEYWORD)||(aaa.item.ty===TY_KEYWORD&&bbb.item.ty!==TY_PRIMITIVE)){return-1}if((bbb.item.ty===TY_PRIMITIVE&&aaa.item.ty!==TY_PRIMITIVE)||(bbb.item.ty===TY_KEYWORD&&aaa.item.ty!==TY_KEYWORD)){return 1}a=(aaa.item.desc==="");b=(bbb.item.desc==="");if(a!==b){return a-b}a=aaa.item.ty;b=bbb.item.ty;if(a!==b){return a-b}a=aaa.item.path;b=bbb.item.path;if(a!==b){return(a>b?+1:-1)}return 0});for(i=0,len=results.length;i"));return{name:val.substring(0,val.indexOf("<")),generics:values.split(/\s*,\s*/),}}return{name:val,generics:[],}}function getObjectNameFromId(id){if(typeof id==="number"){return searchIndex[id].name}return id}function checkGenerics(obj,val){var tmp_lev,elem_name;if(val.generics.length>0){if(obj.length>GENERICS_DATA&&obj[GENERICS_DATA].length>=val.generics.length){var elems=Object.create(null);var elength=object[GENERICS_DATA].length;for(var x=0;xGENERICS_DATA&&obj[GENERICS_DATA].length>=val.generics.length){var elems=Object.create(null);len=obj[GENERICS_DATA].length;for(x=0;xGENERICS_DATA&&obj[GENERICS_DATA].length!==0){var tmp_lev=checkGenerics(obj,val);if(tmp_lev<=MAX_LEV_DISTANCE){return tmp_lev}}else{return 0}}if(literalSearch===true){if(obj.length>GENERICS_DATA&&obj[GENERICS_DATA].length>0){return obj[GENERICS_DATA].some(function(name){return name===val.name})}return false}lev_distance=Math.min(levenshtein(obj[NAME],val.name),lev_distance);if(lev_distance<=MAX_LEV_DISTANCE){lev_distance=Math.ceil((checkGenerics(obj,val)+lev_distance)/2)}else if(obj.length>GENERICS_DATA&&obj[GENERICS_DATA].length>0){var olength=obj[GENERICS_DATA].length;for(x=0;x0){var length=obj.type[INPUTS_DATA].length;for(var i=0;iOUTPUT_DATA){var ret=obj.type[OUTPUT_DATA];if(typeof ret[0]==="string"){ret=[ret]}for(var x=0,len=ret.length;xlength){return MAX_LEV_DISTANCE+1}for(var i=0;ilength){break}var lev_total=0;var aborted=false;for(var x=0;xMAX_LEV_DISTANCE){aborted=true;break}lev_total+=lev}if(aborted===false){ret_lev=Math.min(ret_lev,Math.round(lev_total/clength))}}return ret_lev}function typePassesFilter(filter,type){if(filter<=NO_TYPE_FILTER)return true;if(filter===type)return true;var name=itemTypes[type];switch(itemTypes[filter]){case"constant":return name==="associatedconstant";case"fn":return name==="method"||name==="tymethod";case"type":return name==="primitive"||name==="associatedtype";case"trait":return name==="traitalias"}return false}function createAliasFromItem(item){return{crate:item.crate,name:item.name,path:item.path,desc:item.desc,ty:item.ty,parent:item.parent,type:item.type,is_alias:true,}}function handleAliases(ret,query,filterCrates){var aliases=[];var crateAliases=[];if(filterCrates!==undefined){if(ALIASES[filterCrates]&&ALIASES[filterCrates][query.search]){var query_aliases=ALIASES[filterCrates][query.search];var len=query_aliases.length;for(var i=0;iMAX_RESULTS){ret.others.pop()}};onEach(aliases,pushFunc);onEach(crateAliases,pushFunc)}var nSearchWords=searchWords.length;var i,it;var ty;var fullId;var returned;var in_args;var len;if((val.charAt(0)==="\""||val.charAt(0)==="'")&&val.charAt(val.length-1)===val.charAt(0)){val=extractGenerics(val.substr(1,val.length-2));for(i=0;i")>-1){var trimmer=function(s){return s.trim()};var parts=val.split("->").map(trimmer);var input=parts[0];var inputs=input.split(",").map(trimmer).sort();for(i=0,len=inputs.length;i1?paths.length-1:1);var lev;for(j=0;j1){lev=checkPath(contains,paths[paths.length-1],ty);if(lev>MAX_LEV_DISTANCE){continue}else if(lev>0){lev_add=lev/10}}returned=MAX_LEV_DISTANCE+1;in_args=MAX_LEV_DISTANCE+1;var index=-1;lev=MAX_LEV_DISTANCE+1;fullId=ty.id;if(searchWords[j].indexOf(split[i])>-1||searchWords[j].indexOf(val)>-1||ty.normalizedName.indexOf(val)>-1){if(typePassesFilter(typeFilter,ty.ty)&&results[fullId]===undefined){index=ty.normalizedName.indexOf(val)}}if((lev=levenshtein(searchWords[j],val))<=MAX_LEV_DISTANCE){if(typePassesFilter(typeFilter,ty.ty)===false){lev=MAX_LEV_DISTANCE+1}else{lev+=1}}in_args=findArg(ty,valGenerics,false,typeFilter);returned=checkReturned(ty,valGenerics,false,typeFilter);lev+=lev_add;if(lev>0&&val.length>3&&searchWords[j].indexOf(val)>-1){if(val.length<6){lev-=1}else{lev=0}}if(in_args<=MAX_LEV_DISTANCE){if(results_in_args[fullId]===undefined){results_in_args[fullId]={id:j,index:index,lev:in_args,}}results_in_args[fullId].lev=Math.min(results_in_args[fullId].lev,in_args)}if(returned<=MAX_LEV_DISTANCE){if(results_returned[fullId]===undefined){results_returned[fullId]={id:j,index:index,lev:returned,}}results_returned[fullId].lev=Math.min(results_returned[fullId].lev,returned)}if(index!==-1||lev<=MAX_LEV_DISTANCE){if(index!==-1&&paths.length<2){lev=0}if(results[fullId]===undefined){results[fullId]={id:j,index:index,lev:lev,}}results[fullId].lev=Math.min(results[fullId].lev,lev)}}}var ret={"in_args":sortResults(results_in_args,true),"returned":sortResults(results_returned,true),"others":sortResults(results),};handleAliases(ret,query,filterCrates);return ret}function validateResult(name,path,keys,parent){for(var i=0,len=keys.length;i-1||path.indexOf(keys[i])>-1||(parent!==undefined&&parent.name!==undefined&&parent.name.toLowerCase().indexOf(keys[i])>-1)||levenshtein(name,keys[i])<=MAX_LEV_DISTANCE)){return false}}return true}function getQuery(raw){var matches,type,query;query=raw;matches=query.match(/^(fn|mod|struct|enum|trait|type|const|macro)\s*:\s*/i);if(matches){type=matches[1].replace(/^const$/,"constant");query=query.substring(matches[0].length)}return{raw:raw,query:query,type:type,id:query+type}}function initSearchNav(){var hoverTimeout;var click_func=function(e){var el=e.target;while(el.tagName!=="TR"){el=el.parentNode}var dst=e.target.getElementsByTagName("a");if(dst.length<1){return}dst=dst[0];if(window.location.pathname===dst.pathname){hideSearchResults();document.location.href=dst.href}};var mouseover_func=function(e){if(mouseMovedAfterSearch){var el=e.target;while(el.tagName!=="TR"){el=el.parentNode}clearTimeout(hoverTimeout);hoverTimeout=setTimeout(function(){onEachLazy(document.getElementsByClassName("search-results"),function(e){onEachLazy(e.getElementsByClassName("result"),function(i_e){removeClass(i_e,"highlighted")})});addClass(el,"highlighted")},20)}};onEachLazy(document.getElementsByClassName("search-results"),function(e){onEachLazy(e.getElementsByClassName("result"),function(i_e){i_e.onclick=click_func;i_e.onmouseover=mouseover_func})});search_input.onkeydown=function(e){var actives=[[],[],[]];var current=0;onEachLazy(document.getElementById("results").childNodes,function(e){onEachLazy(e.getElementsByClassName("highlighted"),function(h_e){actives[current].push(h_e)});current+=1});if(e.which===38){if(e.ctrlKey){printTab(currentTab>0?currentTab-1:2)}else{if(!actives[currentTab].length||!actives[currentTab][0].previousElementSibling){return}addClass(actives[currentTab][0].previousElementSibling,"highlighted");removeClass(actives[currentTab][0],"highlighted")}e.preventDefault()}else if(e.which===40){if(e.ctrlKey){printTab(currentTab>1?0:currentTab+1)}else if(!actives[currentTab].length){var results=document.getElementById("results").childNodes;if(results.length>0){var res=results[currentTab].getElementsByClassName("result");if(res.length>0){addClass(res[0],"highlighted")}}}else if(actives[currentTab][0].nextElementSibling){addClass(actives[currentTab][0].nextElementSibling,"highlighted");removeClass(actives[currentTab][0],"highlighted")}e.preventDefault()}else if(e.which===13){if(actives[currentTab].length){document.location.href=actives[currentTab][0].getElementsByTagName("a")[0].href}}else if(e.which===16){}else if(actives[currentTab].length>0){removeClass(actives[currentTab][0],"highlighted")}}}function buildHrefAndPath(item){var displayPath;var href;var type=itemTypes[item.ty];var name=item.name;var path=item.path;if(type==="mod"){displayPath=path+"::";href=window.rootPath+path.replace(/::/g,"/")+"/"+name+"/index.html"}else if(type==="primitive"||type==="keyword"){displayPath="";href=window.rootPath+path.replace(/::/g,"/")+"/"+type+"."+name+".html"}else if(type==="externcrate"){displayPath="";href=window.rootPath+name+"/index.html"}else if(item.parent!==undefined){var myparent=item.parent;var anchor="#"+type+"."+name;var parentType=itemTypes[myparent.ty];var pageType=parentType;var pageName=myparent.name;if(parentType==="primitive"){displayPath=myparent.name+"::"}else if(type==="structfield"&&parentType==="variant"){var enumNameIdx=item.path.lastIndexOf("::");var enumName=item.path.substr(enumNameIdx+2);path=item.path.substr(0,enumNameIdx);displayPath=path+"::"+enumName+"::"+myparent.name+"::";anchor="#variant."+myparent.name+".field."+name;pageType="enum";pageName=enumName}else{displayPath=path+"::"+myparent.name+"::"}href=window.rootPath+path.replace(/::/g,"/")+"/"+pageType+"."+pageName+".html"+anchor}else{displayPath=item.path+"::";href=window.rootPath+item.path.replace(/::/g,"/")+"/"+type+"."+name+".html"}return[displayPath,href]}function escape(content){var h1=document.createElement("h1");h1.textContent=content;return h1.innerHTML}function pathSplitter(path){var tmp=""+path.replace(/::/g,"::");if(tmp.endsWith("")){return tmp.slice(0,tmp.length-6)}return tmp}function addTab(array,query,display){var extraStyle="";if(display===false){extraStyle=" style=\"display: none;\""}var output="";var duplicates={};var length=0;if(array.length>0){output="";array.forEach(function(item){var name,type;name=item.name;type=itemTypes[item.ty];if(item.is_alias!==true){if(duplicates[item.fullPath]){return}duplicates[item.fullPath]=true}length+=1;output+=""});output+="
"+""+(item.is_alias===true?(""+item.alias+"  - see "):"")+item.displayPath+""+name+""+""+""+item.desc+" 
"}else{output="
No results :(
"+"Try on DuckDuckGo?

"+"Or try looking in one of these:
"}return[output,length]}function makeTabHeader(tabNb,text,nbElems){if(currentTab===tabNb){return""}return""}function showResults(results){var search=getSearchElement();if(results.others.length===1&&getSettingValue("go-to-only-result")==="true"&&(!search.firstChild||search.firstChild.innerText!==getSearchLoadingText())){var elem=document.createElement("a");elem.href=results.others[0].href;elem.style.display="none";document.body.appendChild(elem);elem.click();return}var query=getQuery(search_input.value);currentResults=query.id;var ret_others=addTab(results.others,query);var ret_in_args=addTab(results.in_args,query,false);var ret_returned=addTab(results.returned,query,false);if((currentTab===0&&ret_others[1]===0)||(currentTab===1&&ret_in_args[1]===0)||(currentTab===2&&ret_returned[1]===0)){if(ret_others[1]!==0){currentTab=0}else if(ret_in_args[1]!==0){currentTab=1}else if(ret_returned[1]!==0){currentTab=2}}var output="

Results for "+escape(query.query)+(query.type?" (type: "+escape(query.type)+")":"")+"

"+"
"+makeTabHeader(0,"In Names",ret_others[1])+makeTabHeader(1,"In Parameters",ret_in_args[1])+makeTabHeader(2,"In Return Types",ret_returned[1])+"
"+ret_others[0]+ret_in_args[0]+ret_returned[0]+"
";search.innerHTML=output;showSearchResults(search);initSearchNav();var elems=document.getElementById("titles").childNodes;elems[0].onclick=function(){printTab(0)};elems[1].onclick=function(){printTab(1)};elems[2].onclick=function(){printTab(2)};printTab(currentTab)}function execSearch(query,searchWords,filterCrates){function getSmallest(arrays,positions,notDuplicates){var start=null;for(var it=0,len=positions.length;itpositions[it]&&(start===null||start>arrays[it][positions[it]].lev)&&!notDuplicates[arrays[it][positions[it]].fullPath]){start=arrays[it][positions[it]].lev}}return start}function mergeArrays(arrays){var ret=[];var positions=[];var notDuplicates={};for(var x=0,arrays_len=arrays.length;xpositions[x]&&arrays[x][positions[x]].lev===smallest&&!notDuplicates[arrays[x][positions[x]].fullPath]){ret.push(arrays[x][positions[x]]);notDuplicates[arrays[x][positions[x]].fullPath]=true;positions[x]+=1}}}return ret}var queries=query.raw.split(",");var results={"in_args":[],"returned":[],"others":[],};for(var i=0,len=queries.length;i1){return{"in_args":mergeArrays(results.in_args),"returned":mergeArrays(results.returned),"others":mergeArrays(results.others),}}return{"in_args":results.in_args[0],"returned":results.returned[0],"others":results.others[0],}}function getFilterCrates(){var elem=document.getElementById("crate-search");if(elem&&elem.value!=="All crates"&&hasOwnProperty(rawSearchIndex,elem.value)){return elem.value}return undefined}function search(e,forced){var params=getQueryStringParams();var query=getQuery(search_input.value.trim());if(e){e.preventDefault()}if(query.query.length===0){return}if(forced!==true&&query.id===currentResults){if(query.query.length>0){putBackSearch(search_input)}return}searchTitle="Results for "+query.query+" - Rust";if(browserSupportsHistoryApi()){var newURL=getNakedUrl()+"?search="+encodeURIComponent(query.raw)+window.location.hash;if(!history.state&&!params.search){history.pushState(query,"",newURL)}else{history.replaceState(query,"",newURL)}}var filterCrates=getFilterCrates();showResults(execSearch(query,index,filterCrates))}function buildIndex(rawSearchIndex){searchIndex=[];var searchWords=[];var i,word;var currentIndex=0;var id=0;for(var crate in rawSearchIndex){if(!hasOwnProperty(rawSearchIndex,crate)){continue}var crateSize=0;searchWords.push(crate);var normalizedName=crate.indexOf("_")===-1?crate:crate.replace(/_/g,"");var crateRow={crate:crate,ty:1,name:crate,path:"",desc:rawSearchIndex[crate].doc,parent:undefined,type:null,id:id,normalizedName:normalizedName,};id+=1;searchIndex.push(crateRow);currentIndex+=1;var itemTypes=rawSearchIndex[crate].t;var itemNames=rawSearchIndex[crate].n;var itemPaths=rawSearchIndex[crate].q;var itemDescs=rawSearchIndex[crate].d;var itemParentIdxs=rawSearchIndex[crate].i;var itemFunctionSearchTypes=rawSearchIndex[crate].f;var paths=rawSearchIndex[crate].p;var aliases=rawSearchIndex[crate].a;var len=paths.length;for(i=0;i0?paths[itemParentIdxs[i]-1]:undefined,type:itemFunctionSearchTypes[i],id:id,normalizedName:normalizedName,};id+=1;searchIndex.push(row);lastPath=row.path;crateSize+=1}if(aliases){ALIASES[crate]={};var j,local_aliases;for(var alias_name in aliases){if(!aliases.hasOwnProperty(alias_name)){continue}if(!ALIASES[crate].hasOwnProperty(alias_name)){ALIASES[crate][alias_name]=[]}local_aliases=aliases[alias_name];for(j=0,len=local_aliases.length;j0){search_input.value=params.search;search(e)}else{search_input.value="";hideSearchResults()}})}window.onpageshow=function(){var qSearch=getQueryStringParams().search;if(search_input.value===""&&qSearch){search_input.value=qSearch}search()}}index=buildIndex(rawSearchIndex);registerSearchEvents();if(getQueryStringParams().search){search()}};function addSidebarCrates(crates){if(window.rootPath==="../"||window.rootPath==="./"){var sidebar=document.getElementsByClassName("sidebar-elems")[0];if(sidebar){var div=document.createElement("div");div.className="block crate";div.innerHTML="

Crates

";var ul=document.createElement("ul");div.appendChild(ul);for(var i=0;i"+""+"
"+code.outerHTML+"
";list.appendChild(display)}}};if(window.pending_implementors){window.register_implementors(window.pending_implementors)}function labelForToggleButton(sectionIsCollapsed){if(sectionIsCollapsed){return"+"}return"\u2212"}function onEveryMatchingChild(elem,className,func){if(elem&&className&&func){var length=elem.childNodes.length;var nodes=elem.childNodes;for(var i=0;i"+labelForToggleButton(sectionIsCollapsed)+"]";return toggle}function createToggle(toggle,otherMessage,fontSize,extraClass,show){var span=document.createElement("span");span.className="toggle-label";if(show){span.style.display="none"}if(!otherMessage){span.innerHTML=" Expand description"}else{span.innerHTML=otherMessage}if(fontSize){span.style.fontSize=fontSize}var mainToggle=toggle.cloneNode(true);mainToggle.appendChild(span);var wrapper=document.createElement("div");wrapper.className="toggle-wrapper";if(!show){addClass(wrapper,"collapsed");var inner=mainToggle.getElementsByClassName("inner");if(inner&&inner.length>0){inner[0].innerHTML="+"}}if(extraClass){addClass(wrapper,extraClass)}wrapper.appendChild(mainToggle);return wrapper}(function(){var toggles=document.getElementById(toggleAllDocsId);if(toggles){toggles.onclick=toggleAllDocs}var toggle=createSimpleToggle(false);var hideMethodDocs=getSettingValue("auto-hide-method-docs")==="true";var hideImplementors=getSettingValue("auto-collapse-implementors")!=="false";var func=function(e){var next=e.nextElementSibling;if(next&&hasClass(next,"item-info")){next=next.nextElementSibling}if(!next){return}if(hasClass(next,"docblock")){var newToggle=toggle.cloneNode(true);insertAfter(newToggle,e.childNodes[e.childNodes.length-1]);if(hideMethodDocs===true&&hasClass(e,"method")===true){collapseDocs(newToggle,"hide")}}};var funcImpl=function(e){var next=e.nextElementSibling;if(next&&hasClass(next,"item-info")){next=next.nextElementSibling}if(next&&hasClass(next,"docblock")){next=next.nextElementSibling}if(!next){return}if(hasClass(e,"impl")&&(next.getElementsByClassName("method").length>0||next.getElementsByClassName("associatedconstant").length>0)){var newToggle=toggle.cloneNode(true);insertAfter(newToggle,e.childNodes[e.childNodes.length-1]);if(hideImplementors===true&&e.parentNode.id==="implementors-list"){collapseDocs(newToggle,"hide")}}};onEachLazy(document.getElementsByClassName("method"),func);onEachLazy(document.getElementsByClassName("associatedconstant"),func);onEachLazy(document.getElementsByClassName("impl"),funcImpl);var impl_call=function(){};if(hideMethodDocs===true){impl_call=function(e,newToggle){if(e.id.match(/^impl(?:-\d+)?$/)===null){if(hasClass(e,"impl")===true){collapseDocs(newToggle,"hide")}}}}var newToggle=document.createElement("a");newToggle.href="javascript:void(0)";newToggle.className="collapse-toggle hidden-default collapsed";newToggle.innerHTML="["+labelForToggleButton(true)+"] Show hidden undocumented items";function toggleClicked(){if(hasClass(this,"collapsed")){removeClass(this,"collapsed");onEachLazy(this.parentNode.getElementsByClassName("hidden"),function(x){if(hasClass(x,"content")===false){removeClass(x,"hidden");addClass(x,"x")}},true);this.innerHTML="["+labelForToggleButton(false)+"] Hide undocumented items"}else{addClass(this,"collapsed");onEachLazy(this.parentNode.getElementsByClassName("x"),function(x){if(hasClass(x,"content")===false){addClass(x,"hidden");removeClass(x,"x")}},true);this.innerHTML="["+labelForToggleButton(true)+"] Show hidden undocumented items"}}onEachLazy(document.getElementsByClassName("impl-items"),function(e){onEachLazy(e.getElementsByClassName("associatedconstant"),func);var hiddenElems=Array.prototype.slice.call(e.getElementsByClassName("hidden"));var needToggle=hiddenElems.some(function(hiddenElem){return hasClass(hiddenElem,"content")===false&&hasClass(hiddenElem,"docblock")===false});if(needToggle===true){var inner_toggle=newToggle.cloneNode(true);inner_toggle.onclick=toggleClicked;e.insertBefore(inner_toggle,e.firstChild);impl_call(e.previousSibling,inner_toggle)}});var currentType=document.getElementsByClassName("type-decl")[0];var className=null;if(currentType){currentType=currentType.getElementsByClassName("rust")[0];if(currentType){currentType.classList.forEach(function(item){if(item!=="main"){className=item;return true}})}}var showItemDeclarations=getSettingValue("auto-hide-"+className);if(showItemDeclarations===null){if(className==="enum"||className==="macro"){showItemDeclarations="false"}else if(className==="struct"||className==="union"||className==="trait"){showItemDeclarations="true"}else{showItemDeclarations=getSettingValue("auto-hide-declarations")}}showItemDeclarations=showItemDeclarations==="false";function buildToggleWrapper(e){if(hasClass(e,"autohide")){var wrap=e.previousElementSibling;if(wrap&&hasClass(wrap,"toggle-wrapper")){var inner_toggle=wrap.childNodes[0];var extra=e.childNodes[0].tagName==="H3";e.style.display="none";addClass(wrap,"collapsed");onEachLazy(inner_toggle.getElementsByClassName("inner"),function(e){e.innerHTML=labelForToggleButton(true)});onEachLazy(inner_toggle.getElementsByClassName("toggle-label"),function(e){e.style.display="inline-block";if(extra===true){e.innerHTML=" Show "+e.childNodes[0].innerHTML}})}}if(e.parentNode.id==="main"){var otherMessage="";var fontSize;var extraClass;if(hasClass(e,"type-decl")){fontSize="20px";otherMessage=" Show declaration";if(showItemDeclarations===false){extraClass="collapsed"}}else if(hasClass(e,"sub-variant")){otherMessage=" Show fields"}else if(hasClass(e,"non-exhaustive")){otherMessage=" This ";if(hasClass(e,"non-exhaustive-struct")){otherMessage+="struct"}else if(hasClass(e,"non-exhaustive-enum")){otherMessage+="enum"}else if(hasClass(e,"non-exhaustive-variant")){otherMessage+="enum variant"}else if(hasClass(e,"non-exhaustive-type")){otherMessage+="type"}otherMessage+=" is marked as non-exhaustive"}else if(hasClass(e.childNodes[0],"impl-items")){extraClass="marg-left"}e.parentNode.insertBefore(createToggle(toggle,otherMessage,fontSize,extraClass,hasClass(e,"type-decl")===false||showItemDeclarations===true),e);if(hasClass(e,"type-decl")===true&&showItemDeclarations===true){collapseDocs(e.previousSibling.childNodes[0],"toggle")}if(hasClass(e,"non-exhaustive")===true){collapseDocs(e.previousSibling.childNodes[0],"toggle")}}}onEachLazy(document.getElementsByClassName("docblock"),buildToggleWrapper);onEachLazy(document.getElementsByClassName("sub-variant"),buildToggleWrapper);autoCollapse(getSettingValue("collapse")==="true");var pageId=getPageId();if(pageId!==null){expandSection(pageId)}}());function createToggleWrapper(tog){var span=document.createElement("span");span.className="toggle-label";span.style.display="none";span.innerHTML=" Expand attributes";tog.appendChild(span);var wrapper=document.createElement("div");wrapper.className="toggle-wrapper toggle-attributes";wrapper.appendChild(tog);return wrapper}(function(){var itemAttributesFunc=function(){};if(getSettingValue("auto-hide-attributes")!=="false"){itemAttributesFunc=function(x){collapseDocs(x.previousSibling.childNodes[0],"toggle")}}var attributesToggle=createToggleWrapper(createSimpleToggle(false));onEachLazy(main.getElementsByClassName("attributes"),function(i_e){var attr_tog=attributesToggle.cloneNode(true);if(hasClass(i_e,"top-attr")===true){addClass(attr_tog,"top-attr")}i_e.parentNode.insertBefore(attr_tog,i_e);itemAttributesFunc(i_e)})}());(function(){var lineNumbersFunc=function(){};if(getSettingValue("line-numbers")==="true"){lineNumbersFunc=function(x){var count=x.textContent.split("\n").length;var elems=[];for(var i=0;i"+getSearchLoadingText()+"";showSearchResults(search)}var sidebar_menu=document.getElementsByClassName("sidebar-menu")[0];if(sidebar_menu){sidebar_menu.onclick=function(){var sidebar=document.getElementsByClassName("sidebar")[0];if(hasClass(sidebar,"mobile")===true){hideSidebar()}else{showSidebar()}}}if(main){onEachLazy(main.getElementsByClassName("loading-content"),function(e){e.remove()});onEachLazy(main.childNodes,function(e){if(e.tagName==="H2"||e.tagName==="H3"){var nextTagName=e.nextElementSibling.tagName;if(nextTagName=="H2"||nextTagName=="H3"){e.nextElementSibling.style.display="flex"}else{e.nextElementSibling.style.display="block"}}})}function addSearchOptions(crates){var elem=document.getElementById("crate-search");if(!elem){return}var savedCrate=getSettingValue("saved-filter-crate");for(var i=0,len=crates.length;ithe rustdoc book.";var container=document.createElement("div");var shortcuts=[["?","Show this help dialog"],["S","Focus the search field"],["T","Focus the theme picker menu"],["↑","Move up in search results"],["↓","Move down in search results"],["ctrl + ↑ / ↓","Switch result tab"],["⏎","Go to active search result"],["+","Expand all sections"],["-","Collapse all sections"],].map(function(x){return"
"+x[0].split(" ").map(function(y,index){return(index&1)===0?""+y+"":" "+y+" "}).join("")+"
"+x[1]+"
"}).join("");var div_shortcuts=document.createElement("div");addClass(div_shortcuts,"shortcuts");div_shortcuts.innerHTML="

Keyboard Shortcuts

"+shortcuts+"
";var infos=["Prefix searches with a type followed by a colon (e.g., fn:) to \ restrict the search to a given item kind.","Accepted kinds are: fn, mod, struct, \ enum, trait, type, macro, \ and const.","Search functions by type signature (e.g., vec -> usize or \ * -> vec)","Search multiple things at once by splitting your query with comma (e.g., \ str,u8 or String,struct:Vec,test)","You can look for items with an exact name by putting double quotes around \ - your request: \"string\"","Look for items inside another one by searching for a path: vec::Vec",].map(x=>"

"+x+"

").join("");var div_infos=document.createElement("div");addClass(div_infos,"infos");div_infos.innerHTML="

Search Tricks

"+infos;container.appendChild(book_info);container.appendChild(div_shortcuts);container.appendChild(div_infos);popup.appendChild(container);insertAfter(popup,getSearchElement());buildHelperPopup=function(){}}onHashChange(null);window.onhashchange=onHashChange}());window.onunload=function(){}; + your request: \"string\"","Look for items inside another one by searching for a path: vec::Vec",].map(function(x){return"

"+x+"

"}).join("");var div_infos=document.createElement("div");addClass(div_infos,"infos");div_infos.innerHTML="

Search Tricks

"+infos;container.appendChild(book_info);container.appendChild(div_shortcuts);container.appendChild(div_infos);popup.appendChild(container);insertAfter(popup,getSearchElement());buildHelperPopup=function(){}}function loadScript(url){var script=document.createElement('script');script.src=url;document.head.append(script)}function setupSearchLoader(){var searchLoaded=false;function loadSearch(){if(!searchLoaded){searchLoaded=true;loadScript(window.searchJS)}}addSearchOptions(window.ALL_CRATES);addSidebarCrates(window.ALL_CRATES);search_input.addEventListener("focus",function(){search_input.origPlaceholder=search_input.placeholder;search_input.placeholder="Type your search here.";loadSearch()});search_input.addEventListener("blur",function(){search_input.placeholder=search_input.origPlaceholder});search_input.removeAttribute('disabled');var crateSearchDropDown=document.getElementById("crate-search");if(crateSearchDropDown){crateSearchDropDown.addEventListener("focus",loadSearch)}var params=getQueryStringParams();if(params.search!==undefined){loadSearch()}}onHashChange(null);window.onhashchange=onHashChange;setupSearchLoader()}()); var el = document.querySelector("img[alt=logo]").closest("a"); if (el.href != "index.html") { el.href = "../index.html"; diff --git a/noscript.css b/noscript.css index 5cbcb90..b833ff8 100644 --- a/noscript.css +++ b/noscript.css @@ -1 +1 @@ - #main>h2+div,#main>h2+h3,#main>h3+div{display:block;}.loading-content{display:none;}#main>h2+div,#main>h3+div{display:block;}#main>h2+h3{display:flex;}#main .impl-items .hidden{display:block !important;} \ No newline at end of file + #main>h2+div,#main>h2+h3,#main>h3+div{display:block;}.loading-content{display:none;}#main>h2+div,#main>h3+div{display:block;}#main>h2+h3{display:flex;}#main .impl-items .hidden{display:block !important;}#main .impl-items h4.hidden{display:flex !important;}#main .attributes{margin-left:0 !important;} \ No newline at end of file diff --git a/proc_macro2/all.html b/proc_macro2/all.html index 9cb1c25..a7626e2 100644 --- a/proc_macro2/all.html +++ b/proc_macro2/all.html @@ -1,6 +1,7 @@ -List of all items in this crate +List of all items in this crate -

[−] +

List of all items[−] - List of all items

Structs

Enums

\ No newline at end of file +

Structs

Enums

+ \ No newline at end of file diff --git a/proc_macro2/enum.Delimiter.html b/proc_macro2/enum.Delimiter.html index e736c58..cbdac9d 100644 --- a/proc_macro2/enum.Delimiter.html +++ b/proc_macro2/enum.Delimiter.html @@ -1,7 +1,7 @@ -proc_macro2::Delimiter - Rust +proc_macro2::Delimiter - Rust -

[−][src]Enum proc_macro2::Delimiter

pub enum Delimiter {
+
Enum proc_macro2::Delimiter[−][src]
pub enum Delimiter {
     Parenthesis,
     Brace,
     Bracket,
@@ -14,27 +14,28 @@
 
Bracket
[ ... ]

 
None
Ø ... Ø

 
An implicit delimiter, that may, for example, appear around tokens
-coming from a "macro variable" $var. It is important to preserve
+coming from a “macro variable” $var. It is important to preserve
 operator priorities in cases like $var * 3 where $var is 1 + 2.
 Implicit delimiters may not survive roundtrip of a token stream through
 a string.

-
Trait Implementations
impl Clone for Delimiter[src]
impl Copy for Delimiter[src]
impl Debug for Delimiter[src]
impl Eq for Delimiter[src]
impl PartialEq<Delimiter> for Delimiter[src]
Trait Implementations
impl Clone for Delimiter[src]
impl Copy for Delimiter[src]
impl Debug for Delimiter[src]
impl Eq for Delimiter[src]
impl PartialEq<Delimiter> for Delimiter[src]
impl StructuralEq for Delimiter[src]
impl StructuralPartialEq for Delimiter[src]
Auto Trait Implementations
Blanket Implementations
impl<T> Any for T where
    T: 'static + ?Sized, [src]
impl<T> Borrow<T> for T where
    T: ?Sized, [src]
impl<T> BorrowMut<T> for T where
    T: ?Sized, [src]
impl<T> From<T> for T[src]
impl<T, U> Into<U> for T where
    U: From<T>, [src]
impl<T> ToOwned for T where
    T: Clone, [src]
type Owned = T
The resulting type after obtaining ownership.

-
impl StructuralEq for Delimiter[src]
impl StructuralPartialEq for Delimiter[src]
Auto Trait Implementations
Blanket Implementations
impl<T> Any for T where
    T: 'static + ?Sized, [src]
impl<T> Borrow<T> for T where
    T: ?Sized, [src]
impl<T> BorrowMut<T> for T where
    T: ?Sized, [src]
impl<T> From<T> for T[src]
impl<T, U> Into<U> for T where
    U: From<T>, [src]
impl<T> ToOwned for T where
    T: Clone, [src]
type Owned = T
The resulting type after obtaining ownership.

+
impl<T, U> TryFrom<U> for T where
    U: Into<T>, [src]
type Error = Infallible
The type returned in the event of a conversion error.

-
impl<T, U> TryInto<U> for T where
    U: TryFrom<T>, [src]
type Error = <U as TryFrom<T>>::Error
The type returned in the event of a conversion error.

-

\ No newline at end of file
+

impl<T, U> TryFrom<U> for T where
    U: Into<T>, [src]

type Error = Infallible

The type returned in the event of a conversion error.

+

impl<T, U> TryInto<U> for T where
    U: TryFrom<T>, [src]

type Error = <U as TryFrom<T>>::Error

The type returned in the event of a conversion error.

+
+ \ No newline at end of file diff --git a/proc_macro2/enum.Spacing.html b/proc_macro2/enum.Spacing.html index beda8d8..c3b9f43 100644 --- a/proc_macro2/enum.Spacing.html +++ b/proc_macro2/enum.Spacing.html @@ -1,10 +1,10 @@ -proc_macro2::Spacing - Rust +proc_macro2::Spacing - Rust -

[−][src]Enum proc_macro2::Spacing

pub enum Spacing {
+
Enum proc_macro2::Spacing[−][src]
pub enum Spacing {
     Alone,
     Joint,
-}
Whether an Punct is followed immediately by another Punct or followed by
+}

Whether a Punct is followed immediately by another Punct or followed by another token or whitespace.

Variants

@@ -12,23 +12,24 @@ another token or whitespace.

Joint

E.g. + is Joint in += or ' is Joint in '#.

Additionally, single quote ' can join with identifiers to form lifetimes 'ident.

-

Trait Implementations

impl Clone for Spacing[src]

impl Copy for Spacing[src]

impl Debug for Spacing[src]

impl Eq for Spacing[src]

impl PartialEq<Spacing> for Spacing[src]

Trait Implementations

impl Clone for Spacing[src]

impl Copy for Spacing[src]

impl Debug for Spacing[src]

impl Eq for Spacing[src]

impl PartialEq<Spacing> for Spacing[src]

impl StructuralEq for Spacing[src]

impl StructuralPartialEq for Spacing[src]

Auto Trait Implementations

Blanket Implementations

impl<T> Any for T where
    T: 'static + ?Sized, [src]

impl<T> Borrow<T> for T where
    T: ?Sized, [src]

impl<T> BorrowMut<T> for T where
    T: ?Sized, [src]

impl<T> From<T> for T[src]

impl<T, U> Into<U> for T where
    U: From<T>, [src]

impl<T> ToOwned for T where
    T: Clone, [src]

type Owned = T

The resulting type after obtaining ownership.

-

impl StructuralEq for Spacing[src]

impl StructuralPartialEq for Spacing[src]

Auto Trait Implementations

impl RefUnwindSafe for Spacing

impl Send for Spacing

impl Sync for Spacing

impl Unpin for Spacing

impl UnwindSafe for Spacing

Blanket Implementations

impl<T> Any for T where
    T: 'static + ?Sized, [src]

impl<T> Borrow<T> for T where
    T: ?Sized, [src]

impl<T> BorrowMut<T> for T where
    T: ?Sized, [src]

impl<T> From<T> for T[src]

impl<T, U> Into<U> for T where
    U: From<T>, [src]

impl<T> ToOwned for T where
    T: Clone, [src]

type Owned = T

The resulting type after obtaining ownership.

+

impl<T, U> TryFrom<U> for T where
    U: Into<T>, [src]

type Error = Infallible

The type returned in the event of a conversion error.

-

impl<T, U> TryInto<U> for T where
    U: TryFrom<T>, [src]

type Error = <U as TryFrom<T>>::Error

The type returned in the event of a conversion error.

-
\ No newline at end of file +

impl<T, U> TryFrom<U> for T where
    U: Into<T>, [src]

type Error = Infallible

The type returned in the event of a conversion error.

+

impl<T, U> TryInto<U> for T where
    U: TryFrom<T>, [src]

type Error = <U as TryFrom<T>>::Error

The type returned in the event of a conversion error.

+
+ \ No newline at end of file diff --git a/proc_macro2/enum.TokenTree.html b/proc_macro2/enum.TokenTree.html index 8dbb199..53f0256 100644 --- a/proc_macro2/enum.TokenTree.html +++ b/proc_macro2/enum.TokenTree.html @@ -1,7 +1,7 @@ -proc_macro2::TokenTree - Rust +proc_macro2::TokenTree - Rust -

[−][src]Enum proc_macro2::TokenTree

pub enum TokenTree {
+
Enum proc_macro2::TokenTree[−][src]
pub enum TokenTree {
     Group(Group),
     Ident(Ident),
     Punct(Punct),
@@ -13,43 +13,44 @@
 
Ident(Ident)
An identifier.

 
Punct(Punct)
A single punctuation character (+, ,, $, etc.).

 
Literal(Literal)
A literal character ('a'), string ("hello"), number (2.3), etc.

-
Implementations
impl TokenTree[src]
pub fn span(&self) -> Span[src]
Returns the span of this tree, delegating to the span method of
+
Implementations
impl TokenTree[src]
pub fn span(&self) -> Span[src]
Returns the span of this tree, delegating to the span method of
 the contained token or a delimited stream.

-
pub fn set_span(&mut self, span: Span)[src]
Configures the span for only this token.

+
pub fn set_span(&mut self, span: Span)[src]
Configures the span for only this token.

 
Note that if this token is a Group then this method will not configure
 the span of each of the internal tokens, this will simply delegate to
 the set_span method of each variant.

-
Trait Implementations
impl Clone for TokenTree[src]
impl Debug for TokenTree[src]
Prints token tree in a form convenient for debugging.

-
impl Display for TokenTree[src]
Prints the token tree as a string that is supposed to be losslessly
+
Trait Implementations
impl Clone for TokenTree[src]
impl Debug for TokenTree[src]
Prints token tree in a form convenient for debugging.

+
impl Display for TokenTree[src]
Prints the token tree as a string that is supposed to be losslessly
 convertible back into the same token tree (modulo spans), except for
 possibly TokenTree::Groups with Delimiter::None delimiters and negative
 numeric literals.

-
impl Extend<TokenTree> for TokenStream[src]
impl From<Group> for TokenTree[src]
impl From<Ident> for TokenTree[src]
impl From<Literal> for TokenTree[src]
impl From<Punct> for TokenTree[src]
impl From<TokenTree> for TokenStream[src]
impl FromIterator<TokenTree> for TokenStream[src]
Collects a number of token trees into a single stream.

-
Auto Trait Implementations
Blanket Implementations
impl<T> Any for T where
    T: 'static + ?Sized, [src]
impl<T> Borrow<T> for T where
    T: ?Sized, [src]
impl<T> BorrowMut<T> for T where
    T: ?Sized, [src]
impl<T> From<T> for T[src]
impl<T, U> Into<U> for T where
    U: From<T>, [src]
impl<T> ToOwned for T where
    T: Clone, [src]
type Owned = T
The resulting type after obtaining ownership.

-
Auto Trait Implementations
Blanket Implementations
impl<T> Any for T where
    T: 'static + ?Sized, [src]
impl<T> Borrow<T> for T where
    T: ?Sized, [src]
impl<T> BorrowMut<T> for T where
    T: ?Sized, [src]
impl<T> From<T> for T[src]
impl<T, U> Into<U> for T where
    U: From<T>, [src]
impl<T> ToOwned for T where
    T: Clone, [src]
type Owned = T
The resulting type after obtaining ownership.

+
impl<T> ToString for T where
    T: Display + ?Sized, [src]
impl<T, U> TryFrom<U> for T where
    U: Into<T>, [src]
type Error = Infallible
The type returned in the event of a conversion error.

-
impl<T, U> TryInto<U> for T where
    U: TryFrom<T>, [src]
type Error = <U as TryFrom<T>>::Error
The type returned in the event of a conversion error.

-

\ No newline at end of file
+

impl<T> ToString for T where
    T: Display + ?Sized, [src]

impl<T, U> TryFrom<U> for T where
    U: Into<T>, [src]

type Error = Infallible

The type returned in the event of a conversion error.

+

impl<T, U> TryInto<U> for T where
    U: TryFrom<T>, [src]

type Error = <U as TryFrom<T>>::Error

The type returned in the event of a conversion error.

+
+ \ No newline at end of file diff --git a/proc_macro2/index.html b/proc_macro2/index.html index 4679575..05e3152 100644 --- a/proc_macro2/index.html +++ b/proc_macro2/index.html @@ -1,7 +1,7 @@ -proc_macro2 - Rust +proc_macro2 - Rust -

[−][src]Crate proc_macro2

A wrapper around the procedural macro API of the compiler's proc_macro +

Crate proc_macro2[−][src]

A wrapper around the procedural macro API of the compiler’s proc_macro crate. This library serves two purposes:

  • @@ -38,7 +38,7 @@ a macro to be testable in isolation, they must be implemented using proc_macro::TokenStream::from(output) }
-

If parsing with Syn, you'll use parse_macro_input! instead to +

If parsing with Syn, you’ll use parse_macro_input! instead to propagate parse errors correctly back to the compiler when parsing fails.

Unstable features

The default feature set of proc-macro2 tracks the most recent stable @@ -68,12 +68,13 @@ a different thread.

Literal

A literal string ("hello"), byte string (b"hello"), character ('a'), byte character (b'a'), an integer or floating point number with or without a suffix (1, 1u8, 2.3, 2.3f32).

-Punct

An Punct is an single punctuation character like +, - or #.

+Punct

A Punct is a single punctuation character like +, - or #.

Span

A region of source code, along with macro expansion information.

TokenStream

An abstract stream of tokens, or more concretely a sequence of token trees.

Enums

Delimiter

Describes how a sequence of token trees is delimited.

-
Spacing

Whether an Punct is followed immediately by another Punct or followed by +

Spacing

Whether a Punct is followed immediately by another Punct or followed by another token or whitespace.

TokenTree

A single token or a delimited sequence of token trees (e.g. [1, (), ..]).

-
\ No newline at end of file +
+ \ No newline at end of file diff --git a/proc_macro2/sidebar-items.js b/proc_macro2/sidebar-items.js index 5667e02..3ea8163 100644 --- a/proc_macro2/sidebar-items.js +++ b/proc_macro2/sidebar-items.js @@ -1 +1 @@ -initSidebarItems({"enum":[["Delimiter","Describes how a sequence of token trees is delimited."],["Spacing","Whether an `Punct` is followed immediately by another `Punct` or followed by another token or whitespace."],["TokenTree","A single token or a delimited sequence of token trees (e.g. `[1, (), ..]`)."]],"mod":[["token_stream","Public implementation details for the `TokenStream` type, such as iterators."]],"struct":[["Group","A delimited token stream."],["Ident","A word of Rust code, which may be a keyword or legal variable name."],["LexError","Error returned from `TokenStream::from_str`."],["Literal","A literal string (`\"hello\"`), byte string (`b\"hello\"`), character (`'a'`), byte character (`b'a'`), an integer or floating point number with or without a suffix (`1`, `1u8`, `2.3`, `2.3f32`)."],["Punct","An `Punct` is an single punctuation character like `+`, `-` or `#`."],["Span","A region of source code, along with macro expansion information."],["TokenStream","An abstract stream of tokens, or more concretely a sequence of token trees."]]}); \ No newline at end of file +initSidebarItems({"enum":[["Delimiter","Describes how a sequence of token trees is delimited."],["Spacing","Whether a `Punct` is followed immediately by another `Punct` or followed by another token or whitespace."],["TokenTree","A single token or a delimited sequence of token trees (e.g. `[1, (), ..]`)."]],"mod":[["token_stream","Public implementation details for the `TokenStream` type, such as iterators."]],"struct":[["Group","A delimited token stream."],["Ident","A word of Rust code, which may be a keyword or legal variable name."],["LexError","Error returned from `TokenStream::from_str`."],["Literal","A literal string (`\"hello\"`), byte string (`b\"hello\"`), character (`'a'`), byte character (`b'a'`), an integer or floating point number with or without a suffix (`1`, `1u8`, `2.3`, `2.3f32`)."],["Punct","A `Punct` is a single punctuation character like `+`, `-` or `#`."],["Span","A region of source code, along with macro expansion information."],["TokenStream","An abstract stream of tokens, or more concretely a sequence of token trees."]]}); \ No newline at end of file diff --git a/proc_macro2/struct.Group.html b/proc_macro2/struct.Group.html index ccddf47..2abe203 100644 --- a/proc_macro2/struct.Group.html +++ b/proc_macro2/struct.Group.html @@ -1,55 +1,56 @@ -proc_macro2::Group - Rust +proc_macro2::Group - Rust -

[−][src]Struct proc_macro2::Group

pub struct Group { /* fields omitted */ }

A delimited token stream.

+

Struct proc_macro2::Group[−][src]

pub struct Group { /* fields omitted */ }

A delimited token stream.

A Group internally contains a TokenStream which is surrounded by Delimiters.

-

Implementations

impl Group[src]

pub fn new(delimiter: Delimiter, stream: TokenStream) -> Group[src]

Creates a new Group with the given delimiter and token stream.

+

Implementations

impl Group[src]

pub fn new(delimiter: Delimiter, stream: TokenStream) -> Group[src]

Creates a new Group with the given delimiter and token stream.

This constructor will set the span for this group to Span::call_site(). To change the span you can use the set_span method below.

-

pub fn delimiter(&self) -> Delimiter[src]

Returns the delimiter of this Group

-

pub fn stream(&self) -> TokenStream[src]

Returns the TokenStream of tokens that are delimited in this Group.

+

pub fn delimiter(&self) -> Delimiter[src]

Returns the delimiter of this Group

+

pub fn stream(&self) -> TokenStream[src]

Returns the TokenStream of tokens that are delimited in this Group.

Note that the returned token stream does not include the delimiter returned above.

-

pub fn span(&self) -> Span[src]

Returns the span for the delimiters of this token stream, spanning the +

pub fn span(&self) -> Span[src]

Returns the span for the delimiters of this token stream, spanning the entire Group.

pub fn span(&self) -> Span {
            ^^^^^^^
-

pub fn span_open(&self) -> Span[src]

Returns the span pointing to the opening delimiter of this group.

+

pub fn span_open(&self) -> Span[src]

Returns the span pointing to the opening delimiter of this group.

pub fn span_open(&self) -> Span {
                 ^
-

pub fn span_close(&self) -> Span[src]

Returns the span pointing to the closing delimiter of this group.

+

pub fn span_close(&self) -> Span[src]

Returns the span pointing to the closing delimiter of this group.

pub fn span_close(&self) -> Span {
                        ^
-

pub fn set_span(&mut self, span: Span)[src]

Configures the span for this Group's delimiters, but not its internal +

pub fn set_span(&mut self, span: Span)[src]

Configures the span for this Group’s delimiters, but not its internal tokens.

This method will not set the span of all the internal tokens spanned by this group, but rather it will only set the span of the delimiter tokens at the level of the Group.

-

Trait Implementations

impl Clone for Group[src]

impl Debug for Group[src]

impl Display for Group[src]

Prints the group as a string that should be losslessly convertible back +

Trait Implementations

impl Clone for Group[src]

impl Debug for Group[src]

impl Display for Group[src]

Prints the group as a string that should be losslessly convertible back into the same group (modulo spans), except for possibly TokenTree::Groups with Delimiter::None delimiters.

-

impl From<Group> for TokenTree[src]

Auto Trait Implementations

Blanket Implementations

impl<T> Any for T where
    T: 'static + ?Sized, [src]

impl<T> Borrow<T> for T where
    T: ?Sized, [src]

impl<T> BorrowMut<T> for T where
    T: ?Sized, [src]

impl<T> From<T> for T[src]

impl<T, U> Into<U> for T where
    U: From<T>, [src]

impl<T> ToOwned for T where
    T: Clone, [src]

type Owned = T

The resulting type after obtaining ownership.

-

Auto Trait Implementations

impl RefUnwindSafe for Group

impl !Send for Group

impl !Sync for Group

impl Unpin for Group

impl UnwindSafe for Group

Blanket Implementations

impl<T> Any for T where
    T: 'static + ?Sized, [src]

impl<T> Borrow<T> for T where
    T: ?Sized, [src]

impl<T> BorrowMut<T> for T where
    T: ?Sized, [src]

impl<T> From<T> for T[src]

impl<T, U> Into<U> for T where
    U: From<T>, [src]

impl<T> ToOwned for T where
    T: Clone, [src]

type Owned = T

The resulting type after obtaining ownership.

+

impl<T> ToString for T where
    T: Display + ?Sized, [src]

impl<T, U> TryFrom<U> for T where
    U: Into<T>, [src]

type Error = Infallible

The type returned in the event of a conversion error.

-

impl<T, U> TryInto<U> for T where
    U: TryFrom<T>, [src]

type Error = <U as TryFrom<T>>::Error

The type returned in the event of a conversion error.

-
\ No newline at end of file +

impl<T> ToString for T where
    T: Display + ?Sized, [src]

impl<T, U> TryFrom<U> for T where
    U: Into<T>, [src]

type Error = Infallible

The type returned in the event of a conversion error.

+

impl<T, U> TryInto<U> for T where
    U: TryFrom<T>, [src]

type Error = <U as TryFrom<T>>::Error

The type returned in the event of a conversion error.

+
+ \ No newline at end of file diff --git a/proc_macro2/struct.Ident.html b/proc_macro2/struct.Ident.html index 1d35160..f4c079a 100644 --- a/proc_macro2/struct.Ident.html +++ b/proc_macro2/struct.Ident.html @@ -1,7 +1,7 @@ -proc_macro2::Ident - Rust +proc_macro2::Ident - Rust -

[−][src]Struct proc_macro2::Ident

pub struct Ident { /* fields omitted */ }

A word of Rust code, which may be a keyword or legal variable name.

+

Struct proc_macro2::Ident[−][src]

pub struct Ident { /* fields omitted */ }

A word of Rust code, which may be a keyword or legal variable name.

An identifier consists of at least one Unicode code point, the first of which has the XID_Start property and the rest of which have the XID_Continue property.

@@ -51,18 +51,18 @@ method.

if ident_string.len() > 60 { println!("Very long identifier: {}", ident_string) }
-

Implementations

impl Ident[src]

pub fn new(string: &str, span: Span) -> Ident[src]

Creates a new Ident with the given string as well as the specified +

Implementations

impl Ident[src]

pub fn new(string: &str, span: Span) -> Ident[src]

Creates a new Ident with the given string as well as the specified span.

The string argument must be a valid identifier permitted by the language, otherwise the function will panic.

Note that span, currently in rustc, configures the hygiene information for this identifier.

-

As of this time Span::call_site() explicitly opts-in to "call-site" +

As of this time Span::call_site() explicitly opts-in to “call-site” hygiene meaning that identifiers created with this span will be resolved as if they were written directly at the location of the macro call, and other code at the macro call site will be able to refer to them as well.

Later spans like Span::def_site() will allow to opt-in to -"definition-site" hygiene meaning that identifiers created with this +“definition-site” hygiene meaning that identifiers created with this span will be resolved at the location of the macro definition and other code at the macro call site will not be able to refer to them.

Due to the current importance of hygiene this constructor, unlike other @@ -75,47 +75,48 @@ need to handle an error case, use style="padding-right:0;">syn::parse_str::<Ident> rather than Ident::new.

-

pub fn span(&self) -> Span[src]

Returns the span of this Ident.

-

pub fn set_span(&mut self, span: Span)[src]

Configures the span of this Ident, possibly changing its hygiene +

pub fn span(&self) -> Span[src]

Returns the span of this Ident.

+

pub fn set_span(&mut self, span: Span)[src]

Configures the span of this Ident, possibly changing its hygiene context.

-

Trait Implementations

impl Clone for Ident[src]

impl Debug for Ident[src]

impl Display for Ident[src]

Prints the identifier as a string that should be losslessly convertible back +

Trait Implementations

impl Clone for Ident[src]

impl Debug for Ident[src]

impl Display for Ident[src]

Prints the identifier as a string that should be losslessly convertible back into the same identifier.

-

impl Eq for Ident[src]

impl From<Ident> for TokenTree[src]

impl Hash for Ident[src]

impl Ord for Ident[src]

impl PartialEq<Ident> for Ident[src]

impl Eq for Ident[src]

impl From<Ident> for TokenTree[src]

impl Hash for Ident[src]

impl Ord for Ident[src]

impl PartialEq<Ident> for Ident[src]

impl<T: ?Sized> PartialEq<T> for Ident where
    T: AsRef<str>, [src]

impl<T: ?Sized> PartialEq<T> for Ident where
    T: AsRef<str>, [src]

impl PartialOrd<Ident> for Ident[src]

impl PartialOrd<Ident> for Ident[src]

Auto Trait Implementations

Blanket Implementations

impl<T> Any for T where
    T: 'static + ?Sized, [src]

impl<T> Borrow<T> for T where
    T: ?Sized, [src]

impl<T> BorrowMut<T> for T where
    T: ?Sized, [src]

impl<T> From<T> for T[src]

impl<T, U> Into<U> for T where
    U: From<T>, [src]

impl<T> ToOwned for T where
    T: Clone, [src]

type Owned = T

The resulting type after obtaining ownership.

-

Auto Trait Implementations

impl RefUnwindSafe for Ident

impl !Send for Ident

impl !Sync for Ident

impl Unpin for Ident

impl UnwindSafe for Ident

Blanket Implementations

impl<T> Any for T where
    T: 'static + ?Sized, [src]

impl<T> Borrow<T> for T where
    T: ?Sized, [src]

impl<T> BorrowMut<T> for T where
    T: ?Sized, [src]

impl<T> From<T> for T[src]

impl<T, U> Into<U> for T where
    U: From<T>, [src]

impl<T> ToOwned for T where
    T: Clone, [src]

type Owned = T

The resulting type after obtaining ownership.

+

impl<T> ToString for T where
    T: Display + ?Sized, [src]

impl<T, U> TryFrom<U> for T where
    U: Into<T>, [src]

type Error = Infallible

The type returned in the event of a conversion error.

-

impl<T, U> TryInto<U> for T where
    U: TryFrom<T>, [src]

type Error = <U as TryFrom<T>>::Error

The type returned in the event of a conversion error.

-
\ No newline at end of file +

impl<T> ToString for T where
    T: Display + ?Sized, [src]

impl<T, U> TryFrom<U> for T where
    U: Into<T>, [src]

type Error = Infallible

The type returned in the event of a conversion error.

+

impl<T, U> TryInto<U> for T where
    U: TryFrom<T>, [src]

type Error = <U as TryFrom<T>>::Error

The type returned in the event of a conversion error.

+
+ \ No newline at end of file diff --git a/proc_macro2/struct.LexError.html b/proc_macro2/struct.LexError.html index e9d18ce..6c4bb78 100644 --- a/proc_macro2/struct.LexError.html +++ b/proc_macro2/struct.LexError.html @@ -1,21 +1,22 @@ -proc_macro2::LexError - Rust +proc_macro2::LexError - Rust -

[−][src]Struct proc_macro2::LexError

pub struct LexError { /* fields omitted */ }

Error returned from TokenStream::from_str.

-

Trait Implementations

impl Debug for LexError[src]

impl Display for LexError[src]

impl Error for LexError[src]

Auto Trait Implementations

Blanket Implementations

impl<T> Any for T where
    T: 'static + ?Sized, [src]

impl<T> Borrow<T> for T where
    T: ?Sized, [src]

impl<T> BorrowMut<T> for T where
    T: ?Sized, [src]

impl<T> From<T> for T[src]

impl<T, U> Into<U> for T where
    U: From<T>, [src]

impl<T> ToString for T where
    T: Display + ?Sized, [src]

impl<T, U> TryFrom<U> for T where
    U: Into<T>, [src]

type Error = Infallible

The type returned in the event of a conversion error.

-

impl<T, U> TryInto<U> for T where
    U: TryFrom<T>, [src]

type Error = <U as TryFrom<T>>::Error

The type returned in the event of a conversion error.

-
\ No newline at end of file +

Struct proc_macro2::LexError[−][src]

pub struct LexError { /* fields omitted */ }

Error returned from TokenStream::from_str.

+

Implementations

impl LexError[src]

pub fn span(&self) -> Span[src]

Trait Implementations

impl Debug for LexError[src]

impl Display for LexError[src]

impl Error for LexError[src]

Auto Trait Implementations

impl RefUnwindSafe for LexError

impl !Send for LexError

impl !Sync for LexError

impl Unpin for LexError

impl UnwindSafe for LexError

Blanket Implementations

impl<T> Any for T where
    T: 'static + ?Sized, [src]

impl<T> Borrow<T> for T where
    T: ?Sized, [src]

impl<T> BorrowMut<T> for T where
    T: ?Sized, [src]

impl<T> From<T> for T[src]

impl<T, U> Into<U> for T where
    U: From<T>, [src]

impl<T> ToString for T where
    T: Display + ?Sized, [src]

impl<T, U> TryFrom<U> for T where
    U: Into<T>, [src]

type Error = Infallible

The type returned in the event of a conversion error.

+

impl<T, U> TryInto<U> for T where
    U: TryFrom<T>, [src]

type Error = <U as TryFrom<T>>::Error

The type returned in the event of a conversion error.

+
+ \ No newline at end of file diff --git a/proc_macro2/struct.Literal.html b/proc_macro2/struct.Literal.html index d885c37..0f4bba8 100644 --- a/proc_macro2/struct.Literal.html +++ b/proc_macro2/struct.Literal.html @@ -1,254 +1,254 @@ -proc_macro2::Literal - Rust +proc_macro2::Literal - Rust -

[−][src]Struct proc_macro2::Literal

pub struct Literal { /* fields omitted */ }

A literal string ("hello"), byte string (b"hello"), character ('a'), +

Struct proc_macro2::Literal[−][src]

pub struct Literal { /* fields omitted */ }

A literal string ("hello"), byte string (b"hello"), character ('a'), byte character (b'a'), an integer or floating point number with or without a suffix (1, 1u8, 2.3, 2.3f32).

Boolean literals like true and false do not belong here, they are Idents.

-

Implementations

impl Literal[src]

pub fn u8_suffixed(n: u8) -> Literal[src]

Creates a new suffixed integer literal with the specified value.

+

Implementations

impl Literal[src]

pub fn u8_suffixed(n: u8) -> Literal[src]

Creates a new suffixed integer literal with the specified value.

This function will create an integer like 1u32 where the integer value specified is the first part of the token and the integral is also suffixed at the end. Literals created from negative numbers may -not survive rountrips through TokenStream or strings and may be +not survive roundtrips through TokenStream or strings and may be broken into two tokens (- and positive literal).

Literals created through this method have the Span::call_site() span by default, which can be configured with the set_span method below.

-

pub fn u16_suffixed(n: u16) -> Literal[src]

Creates a new suffixed integer literal with the specified value.

+

pub fn u16_suffixed(n: u16) -> Literal[src]

Creates a new suffixed integer literal with the specified value.

This function will create an integer like 1u32 where the integer value specified is the first part of the token and the integral is also suffixed at the end. Literals created from negative numbers may -not survive rountrips through TokenStream or strings and may be +not survive roundtrips through TokenStream or strings and may be broken into two tokens (- and positive literal).

Literals created through this method have the Span::call_site() span by default, which can be configured with the set_span method below.

-

pub fn u32_suffixed(n: u32) -> Literal[src]

Creates a new suffixed integer literal with the specified value.

+

pub fn u32_suffixed(n: u32) -> Literal[src]

Creates a new suffixed integer literal with the specified value.

This function will create an integer like 1u32 where the integer value specified is the first part of the token and the integral is also suffixed at the end. Literals created from negative numbers may -not survive rountrips through TokenStream or strings and may be +not survive roundtrips through TokenStream or strings and may be broken into two tokens (- and positive literal).

Literals created through this method have the Span::call_site() span by default, which can be configured with the set_span method below.

-

pub fn u64_suffixed(n: u64) -> Literal[src]

Creates a new suffixed integer literal with the specified value.

+

pub fn u64_suffixed(n: u64) -> Literal[src]

Creates a new suffixed integer literal with the specified value.

This function will create an integer like 1u32 where the integer value specified is the first part of the token and the integral is also suffixed at the end. Literals created from negative numbers may -not survive rountrips through TokenStream or strings and may be +not survive roundtrips through TokenStream or strings and may be broken into two tokens (- and positive literal).

Literals created through this method have the Span::call_site() span by default, which can be configured with the set_span method below.

-

pub fn u128_suffixed(n: u128) -> Literal[src]

Creates a new suffixed integer literal with the specified value.

+

pub fn u128_suffixed(n: u128) -> Literal[src]

Creates a new suffixed integer literal with the specified value.

This function will create an integer like 1u32 where the integer value specified is the first part of the token and the integral is also suffixed at the end. Literals created from negative numbers may -not survive rountrips through TokenStream or strings and may be +not survive roundtrips through TokenStream or strings and may be broken into two tokens (- and positive literal).

Literals created through this method have the Span::call_site() span by default, which can be configured with the set_span method below.

-

pub fn usize_suffixed(n: usize) -> Literal[src]

Creates a new suffixed integer literal with the specified value.

+

pub fn usize_suffixed(n: usize) -> Literal[src]

Creates a new suffixed integer literal with the specified value.

This function will create an integer like 1u32 where the integer value specified is the first part of the token and the integral is also suffixed at the end. Literals created from negative numbers may -not survive rountrips through TokenStream or strings and may be +not survive roundtrips through TokenStream or strings and may be broken into two tokens (- and positive literal).

Literals created through this method have the Span::call_site() span by default, which can be configured with the set_span method below.

-

pub fn i8_suffixed(n: i8) -> Literal[src]

Creates a new suffixed integer literal with the specified value.

+

pub fn i8_suffixed(n: i8) -> Literal[src]

Creates a new suffixed integer literal with the specified value.

This function will create an integer like 1u32 where the integer value specified is the first part of the token and the integral is also suffixed at the end. Literals created from negative numbers may -not survive rountrips through TokenStream or strings and may be +not survive roundtrips through TokenStream or strings and may be broken into two tokens (- and positive literal).

Literals created through this method have the Span::call_site() span by default, which can be configured with the set_span method below.

-

pub fn i16_suffixed(n: i16) -> Literal[src]

Creates a new suffixed integer literal with the specified value.

+

pub fn i16_suffixed(n: i16) -> Literal[src]

Creates a new suffixed integer literal with the specified value.

This function will create an integer like 1u32 where the integer value specified is the first part of the token and the integral is also suffixed at the end. Literals created from negative numbers may -not survive rountrips through TokenStream or strings and may be +not survive roundtrips through TokenStream or strings and may be broken into two tokens (- and positive literal).

Literals created through this method have the Span::call_site() span by default, which can be configured with the set_span method below.

-

pub fn i32_suffixed(n: i32) -> Literal[src]

Creates a new suffixed integer literal with the specified value.

+

pub fn i32_suffixed(n: i32) -> Literal[src]

Creates a new suffixed integer literal with the specified value.

This function will create an integer like 1u32 where the integer value specified is the first part of the token and the integral is also suffixed at the end. Literals created from negative numbers may -not survive rountrips through TokenStream or strings and may be +not survive roundtrips through TokenStream or strings and may be broken into two tokens (- and positive literal).

Literals created through this method have the Span::call_site() span by default, which can be configured with the set_span method below.

-

pub fn i64_suffixed(n: i64) -> Literal[src]

Creates a new suffixed integer literal with the specified value.

+

pub fn i64_suffixed(n: i64) -> Literal[src]

Creates a new suffixed integer literal with the specified value.

This function will create an integer like 1u32 where the integer value specified is the first part of the token and the integral is also suffixed at the end. Literals created from negative numbers may -not survive rountrips through TokenStream or strings and may be +not survive roundtrips through TokenStream or strings and may be broken into two tokens (- and positive literal).

Literals created through this method have the Span::call_site() span by default, which can be configured with the set_span method below.

-

pub fn i128_suffixed(n: i128) -> Literal[src]

Creates a new suffixed integer literal with the specified value.

+

pub fn i128_suffixed(n: i128) -> Literal[src]

Creates a new suffixed integer literal with the specified value.

This function will create an integer like 1u32 where the integer value specified is the first part of the token and the integral is also suffixed at the end. Literals created from negative numbers may -not survive rountrips through TokenStream or strings and may be +not survive roundtrips through TokenStream or strings and may be broken into two tokens (- and positive literal).

Literals created through this method have the Span::call_site() span by default, which can be configured with the set_span method below.

-

pub fn isize_suffixed(n: isize) -> Literal[src]

Creates a new suffixed integer literal with the specified value.

+

pub fn isize_suffixed(n: isize) -> Literal[src]

Creates a new suffixed integer literal with the specified value.

This function will create an integer like 1u32 where the integer value specified is the first part of the token and the integral is also suffixed at the end. Literals created from negative numbers may -not survive rountrips through TokenStream or strings and may be +not survive roundtrips through TokenStream or strings and may be broken into two tokens (- and positive literal).

Literals created through this method have the Span::call_site() span by default, which can be configured with the set_span method below.

-

pub fn u8_unsuffixed(n: u8) -> Literal[src]

Creates a new unsuffixed integer literal with the specified value.

+

pub fn u8_unsuffixed(n: u8) -> Literal[src]

Creates a new unsuffixed integer literal with the specified value.

This function will create an integer like 1 where the integer value specified is the first part of the token. No suffix is specified on this token, meaning that invocations like Literal::i8_unsuffixed(1) are equivalent to Literal::u32_unsuffixed(1). Literals created from negative numbers -may not survive rountrips through TokenStream or strings and may +may not survive roundtrips through TokenStream or strings and may be broken into two tokens (- and positive literal).

Literals created through this method have the Span::call_site() span by default, which can be configured with the set_span method below.

-

pub fn u16_unsuffixed(n: u16) -> Literal[src]

Creates a new unsuffixed integer literal with the specified value.

+

pub fn u16_unsuffixed(n: u16) -> Literal[src]

Creates a new unsuffixed integer literal with the specified value.

This function will create an integer like 1 where the integer value specified is the first part of the token. No suffix is specified on this token, meaning that invocations like Literal::i8_unsuffixed(1) are equivalent to Literal::u32_unsuffixed(1). Literals created from negative numbers -may not survive rountrips through TokenStream or strings and may +may not survive roundtrips through TokenStream or strings and may be broken into two tokens (- and positive literal).

Literals created through this method have the Span::call_site() span by default, which can be configured with the set_span method below.

-

pub fn u32_unsuffixed(n: u32) -> Literal[src]

Creates a new unsuffixed integer literal with the specified value.

+

pub fn u32_unsuffixed(n: u32) -> Literal[src]

Creates a new unsuffixed integer literal with the specified value.

This function will create an integer like 1 where the integer value specified is the first part of the token. No suffix is specified on this token, meaning that invocations like Literal::i8_unsuffixed(1) are equivalent to Literal::u32_unsuffixed(1). Literals created from negative numbers -may not survive rountrips through TokenStream or strings and may +may not survive roundtrips through TokenStream or strings and may be broken into two tokens (- and positive literal).

Literals created through this method have the Span::call_site() span by default, which can be configured with the set_span method below.

-

pub fn u64_unsuffixed(n: u64) -> Literal[src]

Creates a new unsuffixed integer literal with the specified value.

+

pub fn u64_unsuffixed(n: u64) -> Literal[src]

Creates a new unsuffixed integer literal with the specified value.

This function will create an integer like 1 where the integer value specified is the first part of the token. No suffix is specified on this token, meaning that invocations like Literal::i8_unsuffixed(1) are equivalent to Literal::u32_unsuffixed(1). Literals created from negative numbers -may not survive rountrips through TokenStream or strings and may +may not survive roundtrips through TokenStream or strings and may be broken into two tokens (- and positive literal).

Literals created through this method have the Span::call_site() span by default, which can be configured with the set_span method below.

-

pub fn u128_unsuffixed(n: u128) -> Literal[src]

Creates a new unsuffixed integer literal with the specified value.

+

pub fn u128_unsuffixed(n: u128) -> Literal[src]

Creates a new unsuffixed integer literal with the specified value.

This function will create an integer like 1 where the integer value specified is the first part of the token. No suffix is specified on this token, meaning that invocations like Literal::i8_unsuffixed(1) are equivalent to Literal::u32_unsuffixed(1). Literals created from negative numbers -may not survive rountrips through TokenStream or strings and may +may not survive roundtrips through TokenStream or strings and may be broken into two tokens (- and positive literal).

Literals created through this method have the Span::call_site() span by default, which can be configured with the set_span method below.

-

pub fn usize_unsuffixed(n: usize) -> Literal[src]

Creates a new unsuffixed integer literal with the specified value.

+

pub fn usize_unsuffixed(n: usize) -> Literal[src]

Creates a new unsuffixed integer literal with the specified value.

This function will create an integer like 1 where the integer value specified is the first part of the token. No suffix is specified on this token, meaning that invocations like Literal::i8_unsuffixed(1) are equivalent to Literal::u32_unsuffixed(1). Literals created from negative numbers -may not survive rountrips through TokenStream or strings and may +may not survive roundtrips through TokenStream or strings and may be broken into two tokens (- and positive literal).

Literals created through this method have the Span::call_site() span by default, which can be configured with the set_span method below.

-

pub fn i8_unsuffixed(n: i8) -> Literal[src]

Creates a new unsuffixed integer literal with the specified value.

+

pub fn i8_unsuffixed(n: i8) -> Literal[src]

Creates a new unsuffixed integer literal with the specified value.

This function will create an integer like 1 where the integer value specified is the first part of the token. No suffix is specified on this token, meaning that invocations like Literal::i8_unsuffixed(1) are equivalent to Literal::u32_unsuffixed(1). Literals created from negative numbers -may not survive rountrips through TokenStream or strings and may +may not survive roundtrips through TokenStream or strings and may be broken into two tokens (- and positive literal).

Literals created through this method have the Span::call_site() span by default, which can be configured with the set_span method below.

-

pub fn i16_unsuffixed(n: i16) -> Literal[src]

Creates a new unsuffixed integer literal with the specified value.

+

pub fn i16_unsuffixed(n: i16) -> Literal[src]

Creates a new unsuffixed integer literal with the specified value.

This function will create an integer like 1 where the integer value specified is the first part of the token. No suffix is specified on this token, meaning that invocations like Literal::i8_unsuffixed(1) are equivalent to Literal::u32_unsuffixed(1). Literals created from negative numbers -may not survive rountrips through TokenStream or strings and may +may not survive roundtrips through TokenStream or strings and may be broken into two tokens (- and positive literal).

Literals created through this method have the Span::call_site() span by default, which can be configured with the set_span method below.

-

pub fn i32_unsuffixed(n: i32) -> Literal[src]

Creates a new unsuffixed integer literal with the specified value.

+

pub fn i32_unsuffixed(n: i32) -> Literal[src]

Creates a new unsuffixed integer literal with the specified value.

This function will create an integer like 1 where the integer value specified is the first part of the token. No suffix is specified on this token, meaning that invocations like Literal::i8_unsuffixed(1) are equivalent to Literal::u32_unsuffixed(1). Literals created from negative numbers -may not survive rountrips through TokenStream or strings and may +may not survive roundtrips through TokenStream or strings and may be broken into two tokens (- and positive literal).

Literals created through this method have the Span::call_site() span by default, which can be configured with the set_span method below.

-

pub fn i64_unsuffixed(n: i64) -> Literal[src]

Creates a new unsuffixed integer literal with the specified value.

+

pub fn i64_unsuffixed(n: i64) -> Literal[src]

Creates a new unsuffixed integer literal with the specified value.

This function will create an integer like 1 where the integer value specified is the first part of the token. No suffix is specified on this token, meaning that invocations like Literal::i8_unsuffixed(1) are equivalent to Literal::u32_unsuffixed(1). Literals created from negative numbers -may not survive rountrips through TokenStream or strings and may +may not survive roundtrips through TokenStream or strings and may be broken into two tokens (- and positive literal).

Literals created through this method have the Span::call_site() span by default, which can be configured with the set_span method below.

-

pub fn i128_unsuffixed(n: i128) -> Literal[src]

Creates a new unsuffixed integer literal with the specified value.

+

pub fn i128_unsuffixed(n: i128) -> Literal[src]

Creates a new unsuffixed integer literal with the specified value.

This function will create an integer like 1 where the integer value specified is the first part of the token. No suffix is specified on this token, meaning that invocations like Literal::i8_unsuffixed(1) are equivalent to Literal::u32_unsuffixed(1). Literals created from negative numbers -may not survive rountrips through TokenStream or strings and may +may not survive roundtrips through TokenStream or strings and may be broken into two tokens (- and positive literal).

Literals created through this method have the Span::call_site() span by default, which can be configured with the set_span method below.

-

pub fn isize_unsuffixed(n: isize) -> Literal[src]

Creates a new unsuffixed integer literal with the specified value.

+

pub fn isize_unsuffixed(n: isize) -> Literal[src]

Creates a new unsuffixed integer literal with the specified value.

This function will create an integer like 1 where the integer value specified is the first part of the token. No suffix is specified on this token, meaning that invocations like Literal::i8_unsuffixed(1) are equivalent to Literal::u32_unsuffixed(1). Literals created from negative numbers -may not survive rountrips through TokenStream or strings and may +may not survive roundtrips through TokenStream or strings and may be broken into two tokens (- and positive literal).

Literals created through this method have the Span::call_site() span by default, which can be configured with the set_span method below.

-

pub fn f64_unsuffixed(f: f64) -> Literal[src]

Creates a new unsuffixed floating-point literal.

+

pub fn f64_unsuffixed(f: f64) -> Literal[src]

Creates a new unsuffixed floating-point literal.

This constructor is similar to those like Literal::i8_unsuffixed where -the float's value is emitted directly into the token but no suffix is +the float’s value is emitted directly into the token but no suffix is used, so it may be inferred to be a f64 later in the compiler. Literals created from negative numbers may not survive rountrips through TokenStream or strings and may be broken into two tokens (- and @@ -256,7 +256,7 @@ positive literal).

Panics

This function requires that the specified float is finite, for example if it is infinity or NaN this function will panic.

-

pub fn f64_suffixed(f: f64) -> Literal[src]

Creates a new suffixed floating-point literal.

+

pub fn f64_suffixed(f: f64) -> Literal[src]

Creates a new suffixed floating-point literal.

This constructor will create a literal like 1.0f64 where the value specified is the preceding part of the token and f64 is the suffix of the token. This token will always be inferred to be an f64 in the @@ -266,9 +266,9 @@ tokens (- and positive literal).

Panics

This function requires that the specified float is finite, for example if it is infinity or NaN this function will panic.

-

pub fn f32_unsuffixed(f: f32) -> Literal[src]

Creates a new unsuffixed floating-point literal.

+

pub fn f32_unsuffixed(f: f32) -> Literal[src]

Creates a new unsuffixed floating-point literal.

This constructor is similar to those like Literal::i8_unsuffixed where -the float's value is emitted directly into the token but no suffix is +the float’s value is emitted directly into the token but no suffix is used, so it may be inferred to be a f64 later in the compiler. Literals created from negative numbers may not survive rountrips through TokenStream or strings and may be broken into two tokens (- and @@ -276,7 +276,7 @@ positive literal).

Panics

This function requires that the specified float is finite, for example if it is infinity or NaN this function will panic.

-

pub fn f32_suffixed(f: f32) -> Literal[src]

Creates a new suffixed floating-point literal.

+

pub fn f32_suffixed(f: f32) -> Literal[src]

Creates a new suffixed floating-point literal.

This constructor will create a literal like 1.0f32 where the value specified is the preceding part of the token and f32 is the suffix of the token. This token will always be inferred to be an f32 in the @@ -286,34 +286,37 @@ tokens (- and positive literal).

Panics

This function requires that the specified float is finite, for example if it is infinity or NaN this function will panic.

-

pub fn string(string: &str) -> Literal[src]

String literal.

-

pub fn character(ch: char) -> Literal[src]

Character literal.

-

pub fn byte_string(s: &[u8]) -> Literal[src]

Byte string literal.

-

pub fn span(&self) -> Span[src]

Returns the span encompassing this literal.

-

pub fn set_span(&mut self, span: Span)[src]

Configures the span associated for this literal.

-

pub fn subspan<R: RangeBounds<usize>>(&self, range: R) -> Option<Span>[src]

Returns a Span that is a subset of self.span() containing only +

pub fn string(string: &str) -> Literal[src]

String literal.

+

pub fn character(ch: char) -> Literal[src]

Character literal.

+

pub fn byte_string(s: &[u8]) -> Literal[src]

Byte string literal.

+

pub fn span(&self) -> Span[src]

Returns the span encompassing this literal.

+

pub fn set_span(&mut self, span: Span)[src]

Configures the span associated for this literal.

+

pub fn subspan<R: RangeBounds<usize>>(&self, range: R) -> Option<Span>[src]

Returns a Span that is a subset of self.span() containing only the source bytes in range range. Returns None if the would-be trimmed span is outside the bounds of self.

Warning: the underlying proc_macro::Literal::subspan method is nightly-only. When called from within a procedural macro not using a nightly compiler, this method will always return None.

-

Trait Implementations

impl Clone for Literal[src]

impl Debug for Literal[src]

impl Display for Literal[src]

impl From<Literal> for TokenTree[src]

Auto Trait Implementations

Blanket Implementations

impl<T> Any for T where
    T: 'static + ?Sized, [src]

impl<T> Borrow<T> for T where
    T: ?Sized, [src]

impl<T> BorrowMut<T> for T where
    T: ?Sized, [src]

impl<T> From<T> for T[src]

impl<T, U> Into<U> for T where
    U: From<T>, [src]

impl<T> ToOwned for T where
    T: Clone, [src]

type Owned = T

The resulting type after obtaining ownership.

-

Trait Implementations

impl Clone for Literal[src]

impl Debug for Literal[src]

impl Display for Literal[src]

impl From<Literal> for TokenTree[src]

impl FromStr for Literal[src]

type Err = LexError

The associated error which can be returned from parsing.

+

Auto Trait Implementations

impl RefUnwindSafe for Literal

impl !Send for Literal

impl !Sync for Literal

impl Unpin for Literal

impl UnwindSafe for Literal

Blanket Implementations

impl<T> Any for T where
    T: 'static + ?Sized, [src]

impl<T> Borrow<T> for T where
    T: ?Sized, [src]

impl<T> BorrowMut<T> for T where
    T: ?Sized, [src]

impl<T> From<T> for T[src]

impl<T, U> Into<U> for T where
    U: From<T>, [src]

impl<T> ToOwned for T where
    T: Clone, [src]

type Owned = T

The resulting type after obtaining ownership.

+

impl<T> ToString for T where
    T: Display + ?Sized, [src]

impl<T, U> TryFrom<U> for T where
    U: Into<T>, [src]

type Error = Infallible

The type returned in the event of a conversion error.

-

impl<T, U> TryInto<U> for T where
    U: TryFrom<T>, [src]

type Error = <U as TryFrom<T>>::Error

The type returned in the event of a conversion error.

-
\ No newline at end of file +

impl<T> ToString for T where
    T: Display + ?Sized, [src]

impl<T, U> TryFrom<U> for T where
    U: Into<T>, [src]

type Error = Infallible

The type returned in the event of a conversion error.

+

impl<T, U> TryInto<U> for T where
    U: TryFrom<T>, [src]

type Error = <U as TryFrom<T>>::Error

The type returned in the event of a conversion error.

+
+ \ No newline at end of file diff --git a/proc_macro2/struct.Punct.html b/proc_macro2/struct.Punct.html index 1197bce..d0cb951 100644 --- a/proc_macro2/struct.Punct.html +++ b/proc_macro2/struct.Punct.html @@ -1,41 +1,42 @@ -proc_macro2::Punct - Rust +proc_macro2::Punct - Rust -

[−][src]Struct proc_macro2::Punct

pub struct Punct { /* fields omitted */ }

An Punct is an single punctuation character like +, - or #.

+

Struct proc_macro2::Punct[−][src]

pub struct Punct { /* fields omitted */ }

A Punct is a single punctuation character like +, - or #.

Multicharacter operators like += are represented as two instances of Punct with different forms of Spacing returned.

-

Implementations

impl Punct[src]

pub fn new(ch: char, spacing: Spacing) -> Punct[src]

Creates a new Punct from the given character and spacing.

+

Implementations

impl Punct[src]

pub fn new(ch: char, spacing: Spacing) -> Punct[src]

Creates a new Punct from the given character and spacing.

The ch argument must be a valid punctuation character permitted by the language, otherwise the function will panic.

The returned Punct will have the default span of Span::call_site() which can be further configured with the set_span method below.

-

pub fn as_char(&self) -> char[src]

Returns the value of this punctuation character as char.

-

pub fn spacing(&self) -> Spacing[src]

Returns the spacing of this punctuation character, indicating whether -it's immediately followed by another Punct in the token stream, so +

pub fn as_char(&self) -> char[src]

Returns the value of this punctuation character as char.

+

pub fn spacing(&self) -> Spacing[src]

Returns the spacing of this punctuation character, indicating whether +it’s immediately followed by another Punct in the token stream, so they can potentially be combined into a multicharacter operator -(Joint), or it's followed by some other token or whitespace (Alone) +(Joint), or it’s followed by some other token or whitespace (Alone) so the operator has certainly ended.

-

pub fn span(&self) -> Span[src]

Returns the span for this punctuation character.

-

pub fn set_span(&mut self, span: Span)[src]

Configure the span for this punctuation character.

-

Trait Implementations

impl Clone for Punct[src]

impl Debug for Punct[src]

impl Display for Punct[src]

Prints the punctuation character as a string that should be losslessly +

pub fn span(&self) -> Span[src]

Returns the span for this punctuation character.

+

pub fn set_span(&mut self, span: Span)[src]

Configure the span for this punctuation character.

+

Trait Implementations

impl Clone for Punct[src]

impl Debug for Punct[src]

impl Display for Punct[src]

Prints the punctuation character as a string that should be losslessly convertible back into the same character.

-

impl From<Punct> for TokenTree[src]

Auto Trait Implementations

Blanket Implementations

impl<T> Any for T where
    T: 'static + ?Sized, [src]

impl<T> Borrow<T> for T where
    T: ?Sized, [src]

impl<T> BorrowMut<T> for T where
    T: ?Sized, [src]

impl<T> From<T> for T[src]

impl<T, U> Into<U> for T where
    U: From<T>, [src]

impl<T> ToOwned for T where
    T: Clone, [src]

type Owned = T

The resulting type after obtaining ownership.

-

Auto Trait Implementations

impl RefUnwindSafe for Punct

impl !Send for Punct

impl !Sync for Punct

impl Unpin for Punct

impl UnwindSafe for Punct

Blanket Implementations

impl<T> Any for T where
    T: 'static + ?Sized, [src]

impl<T> Borrow<T> for T where
    T: ?Sized, [src]

impl<T> BorrowMut<T> for T where
    T: ?Sized, [src]

impl<T> From<T> for T[src]

impl<T, U> Into<U> for T where
    U: From<T>, [src]

impl<T> ToOwned for T where
    T: Clone, [src]

type Owned = T

The resulting type after obtaining ownership.

+

impl<T> ToString for T where
    T: Display + ?Sized, [src]

impl<T, U> TryFrom<U> for T where
    U: Into<T>, [src]

type Error = Infallible

The type returned in the event of a conversion error.

-

impl<T, U> TryInto<U> for T where
    U: TryFrom<T>, [src]

type Error = <U as TryFrom<T>>::Error

The type returned in the event of a conversion error.

-
\ No newline at end of file +

impl<T> ToString for T where
    T: Display + ?Sized, [src]

impl<T, U> TryFrom<U> for T where
    U: Into<T>, [src]

type Error = Infallible

The type returned in the event of a conversion error.

+

impl<T, U> TryInto<U> for T where
    U: TryFrom<T>, [src]

type Error = <U as TryFrom<T>>::Error

The type returned in the event of a conversion error.

+
+ \ No newline at end of file diff --git a/proc_macro2/struct.Span.html b/proc_macro2/struct.Span.html index c8ada60..4f79777 100644 --- a/proc_macro2/struct.Span.html +++ b/proc_macro2/struct.Span.html @@ -1,47 +1,48 @@ -proc_macro2::Span - Rust +proc_macro2::Span - Rust -

[−][src]Struct proc_macro2::Span

pub struct Span { /* fields omitted */ }

A region of source code, along with macro expansion information.

-

Implementations

impl Span[src]

pub fn call_site() -> Span[src]

The span of the invocation of the current procedural macro.

+

Struct proc_macro2::Span[−][src]

pub struct Span { /* fields omitted */ }

A region of source code, along with macro expansion information.

+

Implementations

impl Span[src]

pub fn call_site() -> Span[src]

The span of the invocation of the current procedural macro.

Identifiers created with this span will be resolved as if they were written directly at the macro call location (call-site hygiene) and other code at the macro call site will be able to refer to them as well.

-

pub fn mixed_site() -> Span[src]

The span located at the invocation of the procedural macro, but with +

pub fn mixed_site() -> Span[src]

The span located at the invocation of the procedural macro, but with local variables, labels, and $crate resolved at the definition site of the macro. This is the same hygiene behavior as macro_rules.

This function requires Rust 1.45 or later.

-

pub fn resolved_at(&self, other: Span) -> Span[src]

Creates a new span with the same line/column information as self but +

pub fn resolved_at(&self, other: Span) -> Span[src]

Creates a new span with the same line/column information as self but that resolves symbols as though it were at other.

-

pub fn located_at(&self, other: Span) -> Span[src]

Creates a new span with the same name resolution behavior as self but +

pub fn located_at(&self, other: Span) -> Span[src]

Creates a new span with the same name resolution behavior as self but with the line/column information of other.

-

pub fn unwrap(self) -> Span[src]

Convert proc_macro2::Span to proc_macro::Span.

+

pub fn unwrap(self) -> Span[src]

Convert proc_macro2::Span to proc_macro::Span.

This method is available when building with a nightly compiler, or when building with rustc 1.29+ without semver exempt features.

Panics

Panics if called from outside of a procedural macro. Unlike proc_macro2::Span, the proc_macro::Span type can only exist within the context of a procedural macro invocation.

-

pub fn join(&self, other: Span) -> Option<Span>[src]

Create a new span encompassing self and other.

+

pub fn join(&self, other: Span) -> Option<Span>[src]

Create a new span encompassing self and other.

Returns None if self and other are from different files.

Warning: the underlying proc_macro::Span::join method is nightly-only. When called from within a procedural macro not using a nightly compiler, this method will always return None.

-

Trait Implementations

impl Clone for Span[src]

impl Copy for Span[src]

impl Debug for Span[src]

Prints a span in a form convenient for debugging.

-

impl From<Span> for Span[src]

Auto Trait Implementations

Blanket Implementations

impl<T> Any for T where
    T: 'static + ?Sized, [src]

impl<T> Borrow<T> for T where
    T: ?Sized, [src]

impl<T> BorrowMut<T> for T where
    T: ?Sized, [src]

impl<T> From<T> for T[src]

impl<T, U> Into<U> for T where
    U: From<T>, [src]

impl<T> ToOwned for T where
    T: Clone, [src]

type Owned = T

The resulting type after obtaining ownership.

-

Trait Implementations

impl Clone for Span[src]

impl Copy for Span[src]

impl Debug for Span[src]

Prints a span in a form convenient for debugging.

+

impl From<Span> for Span[src]

Auto Trait Implementations

impl RefUnwindSafe for Span

impl !Send for Span

impl !Sync for Span

impl Unpin for Span

impl UnwindSafe for Span

Blanket Implementations

impl<T> Any for T where
    T: 'static + ?Sized, [src]

impl<T> Borrow<T> for T where
    T: ?Sized, [src]

impl<T> BorrowMut<T> for T where
    T: ?Sized, [src]

impl<T> From<T> for T[src]

impl<T, U> Into<U> for T where
    U: From<T>, [src]

impl<T> ToOwned for T where
    T: Clone, [src]

type Owned = T

The resulting type after obtaining ownership.

+

impl<T, U> TryFrom<U> for T where
    U: Into<T>, [src]

type Error = Infallible

The type returned in the event of a conversion error.

-

impl<T, U> TryInto<U> for T where
    U: TryFrom<T>, [src]

type Error = <U as TryFrom<T>>::Error

The type returned in the event of a conversion error.

-
\ No newline at end of file +

impl<T, U> TryFrom<U> for T where
    U: Into<T>, [src]

type Error = Infallible

The type returned in the event of a conversion error.

+

impl<T, U> TryInto<U> for T where
    U: TryFrom<T>, [src]

type Error = <U as TryFrom<T>>::Error

The type returned in the event of a conversion error.

+
+ \ No newline at end of file diff --git a/proc_macro2/struct.TokenStream.html b/proc_macro2/struct.TokenStream.html index 487b334..02d8e78 100644 --- a/proc_macro2/struct.TokenStream.html +++ b/proc_macro2/struct.TokenStream.html @@ -1,60 +1,61 @@ -proc_macro2::TokenStream - Rust +proc_macro2::TokenStream - Rust -

[−][src]Struct proc_macro2::TokenStream

pub struct TokenStream { /* fields omitted */ }

An abstract stream of tokens, or more concretely a sequence of token trees.

+

Struct proc_macro2::TokenStream[−][src]

pub struct TokenStream { /* fields omitted */ }

An abstract stream of tokens, or more concretely a sequence of token trees.

This type provides interfaces for iterating over token trees and for collecting token trees into one stream.

Token stream is both the input and output of #[proc_macro], #[proc_macro_attribute] and #[proc_macro_derive] definitions.

-

Implementations

impl TokenStream[src]

pub fn new() -> TokenStream[src]

Returns an empty TokenStream containing no token trees.

-

pub fn is_empty(&self) -> bool[src]

Checks if this TokenStream is empty.

-

Trait Implementations

impl Clone for TokenStream[src]

impl Debug for TokenStream[src]

Prints token in a form convenient for debugging.

-

impl Default for TokenStream[src]

TokenStream::default() returns an empty stream, +

Implementations

impl TokenStream[src]

pub fn new() -> TokenStream[src]

Returns an empty TokenStream containing no token trees.

+

pub fn is_empty(&self) -> bool[src]

Checks if this TokenStream is empty.

+

Trait Implementations

impl Clone for TokenStream[src]

impl Debug for TokenStream[src]

Prints token in a form convenient for debugging.

+

impl Default for TokenStream[src]

TokenStream::default() returns an empty stream, i.e. this is equivalent with TokenStream::new().

-

impl Display for TokenStream[src]

Prints the token stream as a string that is supposed to be losslessly +

impl Display for TokenStream[src]

Prints the token stream as a string that is supposed to be losslessly convertible back into the same token stream (modulo spans), except for possibly TokenTree::Groups with Delimiter::None delimiters and negative numeric literals.

-

impl Extend<TokenStream> for TokenStream[src]

impl Extend<TokenTree> for TokenStream[src]

impl From<TokenStream> for TokenStream[src]

impl From<TokenStream> for TokenStream[src]

impl From<TokenTree> for TokenStream[src]

impl FromIterator<TokenStream> for TokenStream[src]

impl FromIterator<TokenTree> for TokenStream[src]

Collects a number of token trees into a single stream.

-

impl FromStr for TokenStream[src]

Attempts to break the string into tokens and parse those tokens into a token +

impl Extend<TokenStream> for TokenStream[src]

impl Extend<TokenTree> for TokenStream[src]

impl From<TokenStream> for TokenStream[src]

impl From<TokenStream> for TokenStream[src]

impl From<TokenTree> for TokenStream[src]

impl FromIterator<TokenStream> for TokenStream[src]

impl FromIterator<TokenTree> for TokenStream[src]

Collects a number of token trees into a single stream.

+

impl FromStr for TokenStream[src]

Attempts to break the string into tokens and parse those tokens into a token stream.

May fail for a number of reasons, for example, if the string contains unbalanced delimiters or characters not existing in the language.

NOTE: Some errors may cause panics instead of returning LexError. We reserve the right to change these errors into LexErrors later.

type Err = LexError

The associated error which can be returned from parsing.

-

impl IntoIterator for TokenStream[src]

type Item = TokenTree

The type of the elements being iterated over.

+

impl IntoIterator for TokenStream[src]

type Item = TokenTree

The type of the elements being iterated over.

type IntoIter = IntoIter

Which kind of iterator are we turning this into?

-

Auto Trait Implementations

Blanket Implementations

impl<T> Any for T where
    T: 'static + ?Sized, [src]

impl<T> Borrow<T> for T where
    T: ?Sized, [src]

impl<T> BorrowMut<T> for T where
    T: ?Sized, [src]

impl<T> From<T> for T[src]

impl<T, U> Into<U> for T where
    U: From<T>, [src]

impl<T> ToOwned for T where
    T: Clone, [src]

type Owned = T

The resulting type after obtaining ownership.

-

Auto Trait Implementations

Blanket Implementations

impl<T> Any for T where
    T: 'static + ?Sized, [src]

impl<T> Borrow<T> for T where
    T: ?Sized, [src]

impl<T> BorrowMut<T> for T where
    T: ?Sized, [src]

impl<T> From<T> for T[src]

impl<T, U> Into<U> for T where
    U: From<T>, [src]

impl<T> ToOwned for T where
    T: Clone, [src]

type Owned = T

The resulting type after obtaining ownership.

+

impl<T> ToString for T where
    T: Display + ?Sized, [src]

impl<T, U> TryFrom<U> for T where
    U: Into<T>, [src]

type Error = Infallible

The type returned in the event of a conversion error.

-

impl<T, U> TryInto<U> for T where
    U: TryFrom<T>, [src]

type Error = <U as TryFrom<T>>::Error

The type returned in the event of a conversion error.

-
\ No newline at end of file +

impl<T> ToString for T where
    T: Display + ?Sized, [src]

impl<T, U> TryFrom<U> for T where
    U: Into<T>, [src]

type Error = Infallible

The type returned in the event of a conversion error.

+

impl<T, U> TryInto<U> for T where
    U: TryFrom<T>, [src]

type Error = <U as TryFrom<T>>::Error

The type returned in the event of a conversion error.

+
+ \ No newline at end of file diff --git a/proc_macro2/token_stream/index.html b/proc_macro2/token_stream/index.html index bdeb8b9..d8459a8 100644 --- a/proc_macro2/token_stream/index.html +++ b/proc_macro2/token_stream/index.html @@ -1,8 +1,9 @@ -proc_macro2::token_stream - Rust +proc_macro2::token_stream - Rust -

[−][src]Module proc_macro2::token_stream

Public implementation details for the TokenStream type, such as iterators.

+

Module proc_macro2::token_stream[−][src]

Public implementation details for the TokenStream type, such as iterators.

Re-exports

pub use crate::TokenStream;

Structs

-
IntoIter

An iterator over TokenStream's TokenTrees.

-
\ No newline at end of file +
IntoIter

An iterator over TokenStream’s TokenTrees.

+
+ \ No newline at end of file diff --git a/proc_macro2/token_stream/sidebar-items.js b/proc_macro2/token_stream/sidebar-items.js index c54420e..c6df11d 100644 --- a/proc_macro2/token_stream/sidebar-items.js +++ b/proc_macro2/token_stream/sidebar-items.js @@ -1 +1 @@ -initSidebarItems({"struct":[["IntoIter","An iterator over `TokenStream`'s `TokenTree`s."]]}); \ No newline at end of file +initSidebarItems({"struct":[["IntoIter","An iterator over `TokenStream`’s `TokenTree`s."]]}); \ No newline at end of file diff --git a/proc_macro2/token_stream/struct.IntoIter.html b/proc_macro2/token_stream/struct.IntoIter.html index 1c945fd..0513eb3 100644 --- a/proc_macro2/token_stream/struct.IntoIter.html +++ b/proc_macro2/token_stream/struct.IntoIter.html @@ -1,137 +1,143 @@ -proc_macro2::token_stream::IntoIter - Rust +proc_macro2::token_stream::IntoIter - Rust -

[−][src]Struct proc_macro2::token_stream::IntoIter

pub struct IntoIter { /* fields omitted */ }

An iterator over TokenStream's TokenTrees.

-

The iteration is "shallow", e.g. the iterator doesn't recurse into +

Struct proc_macro2::token_stream::IntoIter[−][src]

pub struct IntoIter { /* fields omitted */ }

An iterator over TokenStream’s TokenTrees.

+

The iteration is “shallow”, e.g. the iterator doesn’t recurse into delimited groups, and returns whole groups as token trees.

-

Trait Implementations

impl Clone for IntoIter[src]

impl Debug for IntoIter[src]

impl Iterator for IntoIter[src]

type Item = TokenTree

The type of the elements being iterated over.

-
\ No newline at end of file +

impl<T, U> TryFrom<U> for T where
    U: Into<T>, [src]

type Error = Infallible

The type returned in the event of a conversion error.

+

impl<T, U> TryInto<U> for T where
    U: TryFrom<T>, [src]

type Error = <U as TryFrom<T>>::Error

The type returned in the event of a conversion error.

+
+ \ No newline at end of file diff --git a/quote/all.html b/quote/all.html index bbc3e84..a051a94 100644 --- a/quote/all.html +++ b/quote/all.html @@ -1,6 +1,7 @@ -List of all items in this crate +List of all items in this crate -

[−] +

List of all items[−] - List of all items

Traits

Macros

\ No newline at end of file +

Traits

Macros

+ \ No newline at end of file diff --git a/quote/index.html b/quote/index.html index 3d7c274..14eaca5 100644 --- a/quote/index.html +++ b/quote/index.html @@ -1,22 +1,22 @@ -quote - Rust +quote - Rust -

[−][src]Crate quote

github crates-io docs-rs

+

Crate quote[−][src]

github crates-io docs-rs


This crate provides the quote! macro for turning Rust syntax tree data structures into tokens of source code.

Procedural macros in Rust receive a stream of tokens as input, execute arbitrary Rust code to determine how to manipulate those tokens, and produce -a stream of tokens to hand back to the compiler to compile into the caller's +a stream of tokens to hand back to the compiler to compile into the caller’s crate. Quasi-quoting is a solution to one piece of that — producing tokens to return to the compiler.

The idea of quasi-quoting is that we write code that we treat as data. Within the quote! macro, we can write what looks like code to our text -editor or IDE. We get all the benefits of the editor's brace matching, +editor or IDE. We get all the benefits of the editor’s brace matching, syntax highlighting, indentation, and maybe autocompletion. But rather than compiling that as code into the current crate, we can treat it as data, pass it around, mutate it, and eventually hand it back to the compiler as tokens -to compile into the macro caller's crate.

+to compile into the macro caller’s crate.

This crate is motivated by the procedural macro use case, but is a general-purpose Rust quasi-quoting library and is not specific to procedural macros.

@@ -62,4 +62,5 @@ the macro invocation.

IdentFragment

Specialized formatting trait used by format_ident!.

ToTokens

Types that can be interpolated inside a quote! invocation.

TokenStreamExt

TokenStream extension trait with methods for appending tokens.

-
\ No newline at end of file +
+ \ No newline at end of file diff --git a/quote/macro.format_ident.html b/quote/macro.format_ident.html index d55aac2..f99f1e2 100644 --- a/quote/macro.format_ident.html +++ b/quote/macro.format_ident.html @@ -1,7 +1,7 @@ -quote::format_ident - Rust +quote::format_ident - Rust -

[−][src]Macro quote::format_ident

+
Macro quote::format_ident[−][src]
 macro_rules! format_ident {
     ($fmt:expr) => { ... };
     ($fmt:expr, $($rest:tt)*) => { ... };
@@ -82,4 +82,5 @@ identifier.

 
 let upper_hex = format_ident!("Id_{:X}", num);
 assert_eq!(upper_hex, "Id_A");

-

\ No newline at end of file
+
+ \ No newline at end of file diff --git a/quote/macro.quote.html b/quote/macro.quote.html index e0a9616..aea7b0c 100644 --- a/quote/macro.quote.html +++ b/quote/macro.quote.html @@ -1,7 +1,7 @@ -quote::quote - Rust +quote::quote - Rust -

[−][src]Macro quote::quote

+
Macro quote::quote[−][src]
 macro_rules! quote {
     () => { ... };
     ($($tt:tt)*) => { ... };
@@ -83,7 +83,7 @@ macro.

 }

 


 
Combining quoted fragments

-
Usually you don't end up constructing an entire final TokenStream in one
+
Usually you don’t end up constructing an entire final TokenStream in one
 piece. Different parts may come from different helper functions. The tokens
 produced by quote! themselves implement ToTokens and so can be
 interpolated into later quote! invocations to build up a final result.

@@ -99,7 +99,7 @@ interpolated into later quote! invocations to build up a final resu
 


 
Constructing identifiers

 
Suppose we have an identifier ident which came from somewhere in a macro
-input and we need to modify it in some way for the macro output. Let's
+input and we need to modify it in some way for the macro output. Let’s
 consider prepending the identifier with an underscore.

 
Simply interpolating the identifier next to an underscore will not have the
 behavior of concatenating them. The underscore and the identifier will
@@ -131,7 +131,7 @@ will not handle ident being a raw identifier.

 }


Making method calls

-

Let's say our macro requires some type specified in the macro input to have +

Let’s say our macro requires some type specified in the macro input to have a constructor called new. We have the type in a variable called field_type of type syn::Type and want to invoke the constructor.

@@ -211,4 +211,5 @@ instead.

quote! { 0 #( + self.#i.heap_size() )* }
-
\ No newline at end of file +
+ \ No newline at end of file diff --git a/quote/macro.quote_spanned.html b/quote/macro.quote_spanned.html index 9912229..2b42e8a 100644 --- a/quote/macro.quote_spanned.html +++ b/quote/macro.quote_spanned.html @@ -1,7 +1,7 @@ -quote::quote_spanned - Rust +quote::quote_spanned - Rust -

[−][src]Macro quote::quote_spanned

+
Macro quote::quote_spanned[−][src]
 macro_rules! quote_spanned {
     ($span:expr=>) => { ... };
     ($span:expr=> $($tt:tt)*) => { ... };
@@ -55,6 +55,7 @@ input span of their type is highlighted in the error.

    |                     ^^^^^^^^^ `*const ()` cannot be shared between threads safely
 

 
In this example it is important for the where-clause to be spanned with the
-line/column information of the user's input type so that error messages are
+line/column information of the user’s input type so that error messages are
 placed appropriately by the compiler.

-

\ No newline at end of file
+
+ \ No newline at end of file diff --git a/quote/trait.IdentFragment.html b/quote/trait.IdentFragment.html index b6041cd..1c55329 100644 --- a/quote/trait.IdentFragment.html +++ b/quote/trait.IdentFragment.html @@ -1,7 +1,7 @@ -quote::IdentFragment - Rust +quote::IdentFragment - Rust -

[−][src]Trait quote::IdentFragment

pub trait IdentFragment {
+
Trait quote::IdentFragment[−][src]
pub trait IdentFragment {
     fn fmt(&self, f: &mut Formatter<'_>) -> Result;
 
     fn span(&self) -> Option<Span> { ... }
@@ -12,4 +12,5 @@ stripped, if present.

 
Required methods
fn fmt(&self, f: &mut Formatter<'_>) -> Result[src]
Format this value as an identifier fragment.

 
Loading content...
Provided methods
fn span(&self) -> Option<Span>[src]
Span associated with this IdentFragment.

 
If non-None, may be inherited by formatted identifiers.

-
Loading content...
Implementations on Foreign Types
impl<T: IdentFragment + ?Sized> IdentFragment for &T[src]
impl<T: IdentFragment + ?Sized> IdentFragment for &mut T[src]
impl IdentFragment for Ident[src]
impl<T: ?Sized> IdentFragment for Cow<'_, T> where
    T: IdentFragment + ToOwned, [src]
impl IdentFragment for bool[src]
impl IdentFragment for str[src]
impl IdentFragment for String[src]
impl IdentFragment for char[src]
impl IdentFragment for u8[src]
impl IdentFragment for u16[src]
impl IdentFragment for u32[src]
impl IdentFragment for u64[src]
impl IdentFragment for u128[src]
impl IdentFragment for usize[src]
Loading content...
Implementors
Loading content...

\ No newline at end of file
+
Loading content...

Implementations on Foreign Types

impl<T: IdentFragment + ?Sized> IdentFragment for &T[src]

impl<T: IdentFragment + ?Sized> IdentFragment for &mut T[src]

impl IdentFragment for Ident[src]

impl<T: ?Sized> IdentFragment for Cow<'_, T> where
    T: IdentFragment + ToOwned, [src]

impl IdentFragment for bool[src]

impl IdentFragment for str[src]

impl IdentFragment for String[src]

impl IdentFragment for char[src]

impl IdentFragment for u8[src]

impl IdentFragment for u16[src]

impl IdentFragment for u32[src]

impl IdentFragment for u64[src]

impl IdentFragment for u128[src]

impl IdentFragment for usize[src]

Loading content...

Implementors

Loading content...
+ \ No newline at end of file diff --git a/quote/trait.ToTokens.html b/quote/trait.ToTokens.html index e5775ab..163e0ce 100644 --- a/quote/trait.ToTokens.html +++ b/quote/trait.ToTokens.html @@ -1,7 +1,7 @@ -quote::ToTokens - Rust +quote::ToTokens - Rust -

[−][src]Trait quote::ToTokens

pub trait ToTokens {
+
Trait quote::ToTokens[−][src]
pub trait ToTokens {
     fn to_tokens(&self, tokens: &mut TokenStream);
 
     fn to_token_stream(&self) -> TokenStream { ... }
@@ -42,4 +42,5 @@ convenience method for consumers of the ToTokens trait.

 
fn into_token_stream(self) -> TokenStream where
    Self: Sized, [src]
Convert self directly into a TokenStream object.

 
This method is implicitly implemented using to_tokens, and acts as a
 convenience method for consumers of the ToTokens trait.

-
Loading content...

Implementations on Foreign Types

impl<'a, T: ?Sized + ToTokens> ToTokens for &'a T[src]

impl<'a, T: ?Sized + ToTokens> ToTokens for &'a mut T[src]

impl<'a, T: ?Sized + ToOwned + ToTokens> ToTokens for Cow<'a, T>[src]

impl<T: ?Sized + ToTokens> ToTokens for Box<T>[src]

impl<T: ?Sized + ToTokens> ToTokens for Rc<T>[src]

impl<T: ToTokens> ToTokens for Option<T>[src]

impl ToTokens for str[src]

impl ToTokens for String[src]

impl ToTokens for i8[src]

impl ToTokens for i16[src]

impl ToTokens for i32[src]

impl ToTokens for i64[src]

impl ToTokens for i128[src]

impl ToTokens for isize[src]

impl ToTokens for u8[src]

impl ToTokens for u16[src]

impl ToTokens for u32[src]

impl ToTokens for u64[src]

impl ToTokens for u128[src]

impl ToTokens for usize[src]

impl ToTokens for f32[src]

impl ToTokens for f64[src]

impl ToTokens for char[src]

impl ToTokens for bool[src]

impl ToTokens for Group[src]

impl ToTokens for Ident[src]

impl ToTokens for Punct[src]

impl ToTokens for Literal[src]

impl ToTokens for TokenTree[src]

impl ToTokens for TokenStream[src]

Loading content...

Implementors

Loading content...
\ No newline at end of file +Loading content...

Implementations on Foreign Types

impl<'a, T: ?Sized + ToTokens> ToTokens for &'a T[src]

impl<'a, T: ?Sized + ToTokens> ToTokens for &'a mut T[src]

impl<'a, T: ?Sized + ToOwned + ToTokens> ToTokens for Cow<'a, T>[src]

impl<T: ?Sized + ToTokens> ToTokens for Box<T>[src]

impl<T: ?Sized + ToTokens> ToTokens for Rc<T>[src]

impl<T: ToTokens> ToTokens for Option<T>[src]

impl ToTokens for str[src]

impl ToTokens for String[src]

impl ToTokens for i8[src]

impl ToTokens for i16[src]

impl ToTokens for i32[src]

impl ToTokens for i64[src]

impl ToTokens for i128[src]

impl ToTokens for isize[src]

impl ToTokens for u8[src]

impl ToTokens for u16[src]

impl ToTokens for u32[src]

impl ToTokens for u64[src]

impl ToTokens for u128[src]

impl ToTokens for usize[src]

impl ToTokens for f32[src]

impl ToTokens for f64[src]

impl ToTokens for char[src]

impl ToTokens for bool[src]

impl ToTokens for Group[src]

impl ToTokens for Ident[src]

impl ToTokens for Punct[src]

impl ToTokens for Literal[src]

impl ToTokens for TokenTree[src]

impl ToTokens for TokenStream[src]

Loading content...

Implementors

Loading content...
+ \ No newline at end of file diff --git a/quote/trait.TokenStreamExt.html b/quote/trait.TokenStreamExt.html index 33bcae2..adc3b02 100644 --- a/quote/trait.TokenStreamExt.html +++ b/quote/trait.TokenStreamExt.html @@ -1,7 +1,7 @@ -quote::TokenStreamExt - Rust +quote::TokenStreamExt - Rust -

[−][src]Trait quote::TokenStreamExt

pub trait TokenStreamExt: Sealed {
+
Trait quote::TokenStreamExt[−][src]
pub trait TokenStreamExt: Sealed {
     fn append<U>(&mut self, token: U)
    where
        U: Into<TokenTree>;
 
    fn append_all<I>(&mut self, iter: I)
    where
        I: IntoIterator,
        I::Item: ToTokens;
 
    fn append_separated<I, U>(&mut self, iter: I, op: U)
    where
        I: IntoIterator,
        I::Item: ToTokens,
        U: ToTokens;
@@ -29,4 +29,5 @@
 
fn append_terminated<I, U>(&mut self, iter: I, term: U) where
    I: IntoIterator,
    I::Item: ToTokens,
    U: ToTokens, [src]
For use by ToTokens implementations.

 
Appends all tokens in the iterator I, appending U after each
 element, including after the last element of the iterator.

-
Loading content...

Implementations on Foreign Types

impl TokenStreamExt for TokenStream[src]

Loading content...

Implementors

Loading content...
\ No newline at end of file +Loading content...

Implementations on Foreign Types

impl TokenStreamExt for TokenStream[src]

Loading content...

Implementors

Loading content...
+ \ No newline at end of file diff --git a/rustdoc.css b/rustdoc.css index 757de19..e5412cb 100644 --- a/rustdoc.css +++ b/rustdoc.css @@ -1 +1 @@ - @font-face {font-family:'Fira Sans';font-style:normal;font-weight:400;src:local('Fira Sans'),url("FiraSans-Regular.woff") format('woff');}@font-face {font-family:'Fira Sans';font-style:normal;font-weight:500;src:local('Fira Sans Medium'),url("FiraSans-Medium.woff") format('woff');}@font-face {font-family:'Source Serif Pro';font-style:normal;font-weight:400;src:local('Source Serif Pro'),url("SourceSerifPro-Regular.ttf.woff") format('woff');}@font-face {font-family:'Source Serif Pro';font-style:italic;font-weight:400;src:local('Source Serif Pro Italic'),url("SourceSerifPro-It.ttf.woff") format('woff');}@font-face {font-family:'Source Serif Pro';font-style:normal;font-weight:700;src:local('Source Serif Pro Bold'),url("SourceSerifPro-Bold.ttf.woff") format('woff');}@font-face {font-family:'Source Code Pro';font-style:normal;font-weight:400;src:url("SourceCodePro-Regular.woff") format('woff');}@font-face {font-family:'Source Code Pro';font-style:normal;font-weight:600;src:url("SourceCodePro-Semibold.woff") format('woff');}*{-webkit-box-sizing:border-box;-moz-box-sizing:border-box;box-sizing:border-box;}html{content:"";}@media (prefers-color-scheme:light){html{content:"light";}}@media (prefers-color-scheme:dark){html{content:"dark";}}body{font:16px/1.4 "Source Serif Pro",serif;margin:0;position:relative;padding:10px 15px 20px 15px;-webkit-font-feature-settings:"kern","liga";-moz-font-feature-settings:"kern","liga";font-feature-settings:"kern","liga";}h1{font-size:1.5em;}h2{font-size:1.4em;}h3{font-size:1.3em;}h1,h2,h3:not(.impl):not(.method):not(.type):not(.tymethod):not(.notable),h4:not(.method):not(.type):not(.tymethod):not(.associatedconstant){font-weight:500;margin:20px 0 15px 0;padding-bottom:6px;}h1.fqn{border-bottom:1px dashed;margin-top:0;}h1.fqn>.in-band>a:hover{text-decoration:underline;}h2,h3:not(.impl):not(.method):not(.type):not(.tymethod),h4:not(.method):not(.type):not(.tymethod):not(.associatedconstant){border-bottom:1px solid;}h3.impl,h3.method,h4.method,h3.type,h4.type,h4.associatedconstant{flex-basis:100%;font-weight:600;margin-top:16px;margin-bottom:10px;position:relative;}h3.impl,h3.method,h3.type{padding-left:15px;}h1,h2,h3,h4,.sidebar,a.source,.search-input,.content table td:first-child>a,.collapse-toggle,div.item-list .out-of-band,#source-sidebar,#sidebar-toggle{font-family:"Fira Sans",sans-serif;}.content ul.crate a.crate{font:16px/1.6 "Fira Sans";}ol,ul{padding-left:25px;}ul ul,ol ul,ul ol,ol ol{margin-bottom:.6em;}p{margin:0 0 .6em 0;}summary{outline:none;}code,pre,a.test-arrow{font-family:"Source Code Pro",monospace;}.docblock code,.docblock-short code{border-radius:3px;padding:0 0.1em;}.docblock pre code,.docblock-short pre code,.docblock code.spotlight{padding:0;}.docblock code.spotlight :last-child{padding-bottom:0.6em;}pre{padding:14px;}.source .content pre{padding:20px;}img{max-width:100%;}li{position:relative;}.source .content{margin-top:50px;max-width:none;overflow:visible;margin-left:0px;min-width:70em;}nav.sub{font-size:16px;text-transform:uppercase;}.sidebar{width:200px;position:fixed;left:0;top:0;bottom:0;overflow:auto;}*{scrollbar-width:initial;}.sidebar{scrollbar-width:thin;}::-webkit-scrollbar{width:12px;}.sidebar::-webkit-scrollbar{width:8px;}::-webkit-scrollbar-track{-webkit-box-shadow:inset 0;}.sidebar .block>ul>li{margin-right:-10px;}.content,nav{max-width:960px;}.hidden{display:none !important;}.logo-container{height:100px;width:100px;position:relative;margin:20px auto;display:block;margin-top:10px;}.logo-container>img{max-width:100px;max-height:100px;position:absolute;left:50%;top:50%;transform:translate(-50%,-50%);display:block;}.sidebar .location{border:1px solid;font-size:17px;margin:30px 10px 20px 10px;text-align:center;word-wrap:break-word;}.sidebar .version{font-size:15px;text-align:center;border-bottom:1px solid;overflow-wrap:break-word;word-wrap:break-word;word-break:break-word;}.location:empty{border:none;}.location a:first-child{font-weight:500;}.block{padding:0;margin-bottom:14px;}.block h2,.block h3{margin-top:0;margin-bottom:8px;text-align:center;}.block ul,.block li{margin:0 10px;padding:0;list-style:none;}.block a{display:block;text-overflow:ellipsis;overflow:hidden;line-height:15px;padding:7px 5px;font-size:14px;font-weight:300;transition:border 500ms ease-out;}.sidebar-title{border-top:1px solid;border-bottom:1px solid;text-align:center;font-size:17px;margin-bottom:5px;}.sidebar-links{margin-bottom:15px;}.sidebar-links>a{padding-left:10px;width:100%;}.sidebar-menu{display:none;}.content{padding:15px 0;}.source .content pre.rust{white-space:pre;overflow:auto;padding-left:0;}.rustdoc:not(.source) .example-wrap{display:inline-flex;margin-bottom:10px;position:relative;}.example-wrap{width:100%;}.example-wrap>pre.line-number{overflow:initial;border:1px solid;border-top-left-radius:5px;border-bottom-left-radius:5px;padding:13px 8px;text-align:right;}.rustdoc:not(.source) .example-wrap>pre.rust{width:100%;overflow-x:auto;}.rustdoc:not(.source) .example-wrap>pre{margin:0;}#search{margin-left:230px;position:relative;}#results{position:absolute;right:0;left:0;overflow:auto;}#results>table{width:100%;table-layout:fixed;margin-bottom:40px;}.content pre.line-numbers{float:left;border:none;position:relative;-webkit-user-select:none;-moz-user-select:none;-ms-user-select:none;user-select:none;}.line-numbers span{cursor:pointer;}.docblock-short{overflow-wrap:anywhere;}.docblock-short p{display:inline;}.docblock-short p{overflow:hidden;text-overflow:ellipsis;margin:0;}.docblock code,.docblock-short code{white-space:pre-wrap;}.docblock h1,.docblock h2,.docblock h3,.docblock h4,.docblock h5{border-bottom:1px solid;}#main>.docblock h1{font-size:1.3em;}#main>.docblock h2{font-size:1.15em;}#main>.docblock h3,#main>.docblock h4,#main>.docblock h5{font-size:1em;}#main>h2+div,#main>h2+h3,#main>h3+div{display:none;flex-wrap:wrap;}.docblock h1{font-size:1em;}.docblock h2{font-size:0.95em;}.docblock h3,.docblock h4,.docblock h5{font-size:0.9em;}.docblock{margin-left:24px;position:relative;}.content .out-of-band{float:right;font-size:23px;margin:0px;padding:0px;font-weight:normal;}h3.impl>.out-of-band{font-size:21px;}h4.method>.out-of-band{font-size:19px;}h4>code,h3>code,.invisible>code{max-width:calc(100% - 41px);display:block;}.invisible{width:100%;display:inline-block;}.content .in-band{margin:0px;padding:0px;}.in-band>code{display:inline-block;}#main{position:relative;}#main>.since{top:inherit;font-family:"Fira Sans",sans-serif;}.content table:not(.table-display){border-spacing:0 5px;}.content td{vertical-align:top;}.content td:first-child{padding-right:20px;}.content td p:first-child{margin-top:0;}.content td h1,.content td h2{margin-left:0;font-size:1.1em;}.content tr:first-child td{border-top:0;}.docblock table{margin:.5em 0;width:calc(100% - 2px);border:1px dashed;}.docblock table td{padding:.5em;border:1px dashed;}.docblock table th{padding:.5em;text-align:left;border:1px solid;}.fields+table{margin-bottom:1em;}.content .item-list{list-style-type:none;padding:0;}.content .multi-column{-moz-column-count:5;-moz-column-gap:2.5em;-webkit-column-count:5;-webkit-column-gap:2.5em;column-count:5;column-gap:2.5em;}.content .multi-column li{width:100%;display:inline-block;}.content .method{font-size:1em;position:relative;}.content .method .where,.content .fn .where,.content .where.fmt-newline{display:block;font-size:0.8em;}.content .methods>div:not(.notable-traits){margin-left:40px;margin-bottom:15px;}.content .docblock>.impl-items{margin-left:20px;margin-top:-34px;}.content .docblock>.impl-items>h4{border-bottom:0;}.content .docblock>.impl-items .table-display{margin:0;}.content .docblock>.impl-items table td{padding:0;}.toggle-wrapper.marg-left>.collapse-toggle{left:-24px;}.content .docblock>.impl-items .table-display,.impl-items table td{border:none;}.content .item-info code{font-size:90%;}.content .item-info{position:relative;margin-left:33px;margin-top:-13px;}.sub-variant>div>.item-info{margin-top:initial;}.content .item-info::before{content:'⬑';font-size:25px;position:absolute;top:-6px;left:-19px;}.content .impl-items .method,.content .impl-items>.type,.impl-items>.associatedconstant{margin-left:20px;}.content .impl-items .docblock,.content .impl-items .item-info{margin-bottom:.6em;}.content .impl-items>.item-info{margin-left:40px;}.methods>.item-info,.content .impl-items>.item-info{margin-top:-8px;}.impl-items{flex-basis:100%;}#main>.item-info{margin-top:0;}nav:not(.sidebar){border-bottom:1px solid;padding-bottom:10px;margin-bottom:10px;}nav.main{padding:20px 0;text-align:center;}nav.main .current{border-top:1px solid;border-bottom:1px solid;}nav.main .separator{border:1px solid;display:inline-block;height:23px;margin:0 20px;}nav.sum{text-align:right;}nav.sub form{display:inline;}nav.sub,.content{margin-left:230px;}a{text-decoration:none;background:transparent;}.small-section-header:hover>.anchor{display:initial;}.in-band:hover>.anchor,.impl:hover>.anchor{display:inline-block;position:absolute;}.anchor{display:none;position:absolute;left:-7px;}.anchor.field{left:-5px;}.small-section-header>.anchor{left:-28px;padding-right:10px;}.anchor:before{content:'\2002\00a7\2002';}.docblock a:not(.srclink):not(.test-arrow):hover,.docblock-short a:not(.srclink):not(.test-arrow):hover,.item-info a{text-decoration:underline;}.invisible>.srclink,h4>code+.srclink,h3>code+.srclink{position:absolute;top:0;right:0;font-size:17px;font-weight:normal;}.block a.current.crate{font-weight:500;}.search-container{position:relative;}.search-container>div{display:inline-flex;width:calc(100% - 63px);}#crate-search{margin-top:5px;padding:6px;padding-right:19px;flex:none;border:0;border-right:0;border-radius:4px 0 0 4px;outline:none;cursor:pointer;border-right:1px solid;-moz-appearance:none;-webkit-appearance:none;text-indent:0.01px;text-overflow:"";background-repeat:no-repeat;background-color:transparent;background-size:20px;background-position:calc(100% - 1px) 56%;}.search-container>.top-button{position:absolute;right:0;top:10px;}.search-input{-moz-box-sizing:border-box !important;box-sizing:border-box !important;outline:none;border:none;border-radius:1px;margin-top:5px;padding:10px 16px;font-size:17px;transition:border-color 300ms ease;transition:border-radius 300ms ease-in-out;transition:box-shadow 300ms ease-in-out;width:100%;}#crate-search+.search-input{border-radius:0 1px 1px 0;width:calc(100% - 32px);}.search-input:focus{border-radius:2px;border:0;outline:0;}.search-results .desc{white-space:nowrap;text-overflow:ellipsis;overflow:hidden;display:block;}.search-results a{display:block;}.content .search-results td:first-child{padding-right:0;width:50%;}.content .search-results td:first-child a{padding-right:10px;}.content .search-results td:first-child a:after{clear:both;content:"";display:block;}.content .search-results td:first-child a span{float:left;}tr.result span.primitive::after{content:' (primitive type)';font-style:italic;}tr.result span.keyword::after{content:' (keyword)';font-style:italic;}body.blur>:not(#help){filter:blur(8px);-webkit-filter:blur(8px);opacity:.7;}#help{width:100%;height:100vh;position:fixed;top:0;left:0;display:flex;justify-content:center;align-items:center;}#help>div{flex:0 0 auto;box-shadow:0 0 6px rgba(0,0,0,.2);width:550px;height:auto;border:1px solid;}#help dt{float:left;clear:left;display:block;}#help>div>span{text-align:center;display:block;margin:10px 0;font-size:18px;border-bottom:1px solid #ccc;padding-bottom:4px;margin-bottom:6px;}#help dd{margin:5px 35px;}#help .infos{padding-left:0;}#help h1,#help h2{margin-top:0;}#help>div div{width:50%;float:left;padding:0 20px 20px 17px;;}.stab{display:table;border-width:1px;border-style:solid;padding:3px;margin-bottom:5px;font-size:90%;}.stab p{display:inline;}.stab summary{display:list-item;}.stab .emoji{font-size:1.5em;}.module-item .stab{border-radius:3px;display:inline-block;font-size:80%;line-height:1.2;margin-bottom:0;margin-right:.3em;padding:2px;vertical-align:text-bottom;}.module-item.unstable{opacity:0.65;}.since{font-weight:normal;font-size:initial;position:absolute;right:0;top:0;}.impl-items .since,.impl .since,.methods .since{flex-grow:0;padding-left:12px;padding-right:2px;position:initial;}.impl-items .srclink,.impl .srclink,.methods .srclink{flex-grow:0;font-size:17px;font-weight:normal;}.impl-items code,.impl code,.methods code{flex-grow:1;}.impl-items h4,h4.impl,h3.impl,.methods h3{display:flex;flex-basis:100%;font-size:16px;margin-bottom:12px;justify-content:space-between;}.variants_table{width:100%;}.variants_table tbody tr td:first-child{width:1%;}td.summary-column{width:100%;}.summary{padding-right:0px;}pre.rust .question-mark{font-weight:bold;}a.test-arrow{display:inline-block;position:absolute;padding:5px 10px 5px 10px;border-radius:5px;font-size:130%;top:5px;right:5px;z-index:1;}a.test-arrow:hover{text-decoration:none;}.section-header:hover a:before{position:absolute;left:-25px;padding-right:10px;content:'\2002\00a7\2002';}.section-header:hover a{text-decoration:none;}.section-header a{color:inherit;}.collapse-toggle{font-weight:300;position:absolute;left:-23px;top:0;}h3>.collapse-toggle,h4>.collapse-toggle{font-size:0.8em;top:5px;}.toggle-wrapper>.collapse-toggle{left:-24px;margin-top:0px;}.toggle-wrapper{position:relative;margin-top:0;}.toggle-wrapper.collapsed{height:25px;transition:height .2s;margin-bottom:.6em;}.collapse-toggle>.inner{display:inline-block;width:1.2ch;text-align:center;}.collapse-toggle.hidden-default{position:relative;margin-left:20px;}.since+.srclink{display:table-cell;padding-left:10px;}.item-spacer{width:100%;height:12px;}.out-of-band>span.since{position:initial;font-size:20px;margin-right:5px;}.toggle-wrapper>.collapse-toggle{left:0;}.variant+.toggle-wrapper+.docblock>p{margin-top:5px;}.sub-variant,.sub-variant>h3{margin-top:1px !important;}#main>.sub-variant>h3{font-size:15px;margin-left:25px;margin-bottom:5px;}.sub-variant>div{margin-left:20px;margin-bottom:10px;}.sub-variant>div>span{display:block;position:relative;}.toggle-label{display:inline-block;margin-left:4px;margin-top:3px;}.enum>.toggle-wrapper+.docblock,.struct>.toggle-wrapper+.docblock{margin-left:30px;margin-bottom:20px;margin-top:5px;}.docblock>.section-header:first-child{margin-left:15px;margin-top:0;}.docblock>.section-header:first-child:hover>a:before{left:-10px;}.enum>.collapsed,.struct>.collapsed{margin-bottom:25px;}#main>.variant,#main>.structfield{display:block;}.attributes{display:block;margin-top:0px !important;margin-right:0px;margin-bottom:0px !important;margin-left:30px;}.toggle-attributes.collapsed{margin-bottom:0;}.impl-items>.toggle-attributes{margin-left:20px;}.impl-items .attributes{font-weight:500;}:target>code{opacity:1;}.information{position:absolute;left:-25px;margin-top:7px;z-index:1;}.tooltip{position:relative;display:inline-block;cursor:pointer;}.tooltip::after{display:none;text-align:center;padding:5px 3px 3px 3px;border-radius:6px;margin-left:5px;font-size:16px;}.tooltip.ignore::after{content:"This example is not tested";}.tooltip.compile_fail::after{content:"This example deliberately fails to compile";}.tooltip.should_panic::after{content:"This example panics";}.tooltip.edition::after{content:"This code runs with edition " attr(data-edition);}.tooltip::before{content:" ";position:absolute;top:50%;left:16px;margin-top:-5px;border-width:5px;border-style:solid;display:none;}.tooltip:hover::before,.tooltip:hover::after{display:inline;}.tooltip.compile_fail,.tooltip.should_panic,.tooltip.ignore{font-weight:bold;font-size:20px;}.notable-traits-tooltip{display:inline-block;cursor:pointer;}.notable-traits:hover .notable-traits-tooltiptext,.notable-traits .notable-traits-tooltiptext.force-tooltip{display:inline-block;}.notable-traits .notable-traits-tooltiptext{display:none;padding:5px 3px 3px 3px;border-radius:6px;margin-left:5px;z-index:10;font-size:16px;cursor:default;position:absolute;border:1px solid;}.notable-traits-tooltip::after{content:"\00a0\00a0\00a0";}.notable-traits .notable,.notable-traits .docblock{margin:0;}.notable-traits .docblock code.content{margin:0;padding:0;font-size:20px;}pre.rust.rust-example-rendered{position:relative;}pre.rust{tab-size:4;-moz-tab-size:4;}.search-failed{text-align:center;margin-top:20px;}.search-failed>ul{text-align:left;max-width:570px;margin-left:auto;margin-right:auto;}#titles{height:35px;}#titles>button{float:left;width:33.3%;text-align:center;font-size:18px;cursor:pointer;border:0;border-top:2px solid;}#titles>button:not(:last-child){margin-right:1px;width:calc(33.3% - 1px);}#titles>button>div.count{display:inline-block;font-size:16px;}.notable-traits{cursor:pointer;z-index:2;margin-left:5px;}h4>.notable-traits{position:absolute;left:-44px;top:2px;}#all-types{text-align:center;border:1px solid;margin:0 10px;margin-bottom:10px;display:block;border-radius:7px;}#all-types>p{margin:5px 0;}#sidebar-toggle{position:fixed;top:30px;left:300px;z-index:10;padding:3px;border-top-right-radius:3px;border-bottom-right-radius:3px;cursor:pointer;font-weight:bold;transition:left .5s;font-size:1.2em;border:1px solid;border-left:0;}#source-sidebar{position:fixed;top:0;bottom:0;left:0;width:300px;z-index:1;overflow:auto;transition:left .5s;border-right:1px solid;}#source-sidebar>.title{font-size:1.5em;text-align:center;border-bottom:1px solid;margin-bottom:6px;}.theme-picker{position:absolute;left:211px;top:19px;}.theme-picker button{outline:none;}#settings-menu,.help-button{position:absolute;top:10px;}#settings-menu{right:0;outline:none;}.help-button{right:30px;font-family:"Fira Sans",sans-serif;text-align:center;font-size:17px;}#theme-picker,#settings-menu,.help-button{padding:4px;width:27px;height:29px;border:1px solid;border-radius:3px;cursor:pointer;}#theme-choices{display:none;position:absolute;left:0;top:28px;border:1px solid;border-radius:3px;z-index:1;cursor:pointer;}#theme-choices>button{border:none;width:100%;padding:4px 8px;text-align:center;background:rgba(0,0,0,0);}#theme-choices>button:not(:first-child){border-top:1px solid;}@media (min-width:701px){.information:first-child>.tooltip{margin-top:16px;}}@media (max-width:700px){body{padding-top:0px;}.rustdoc>.sidebar{height:45px;min-height:40px;margin:0;margin-left:-15px;padding:0 15px;position:static;z-index:11;}.sidebar>.location{float:right;margin:0px;margin-top:2px;padding:3px 10px 1px 10px;min-height:39px;background:inherit;text-align:left;font-size:24px;}.sidebar .location:empty{padding:0;}.sidebar .logo-container{width:35px;height:35px;margin-top:5px;margin-bottom:5px;float:left;margin-left:50px;}.sidebar .logo-container>img{max-width:35px;max-height:35px;}.sidebar-menu{position:fixed;z-index:10;font-size:2rem;cursor:pointer;width:45px;left:0;text-align:center;display:block;border-bottom:1px solid;border-right:1px solid;height:45px;}.rustdoc.source>.sidebar>.sidebar-menu{display:none;}.sidebar-elems{position:fixed;z-index:1;left:0;top:45px;bottom:0;overflow-y:auto;border-right:1px solid;display:none;}.sidebar>.block.version{border-bottom:none;margin-top:12px;}nav.sub{width:calc(100% - 32px);float:right;}.content{margin-left:0px;}#main{margin-top:45px;padding:0;}.content .in-band{width:100%;}.content h4>.out-of-band{position:inherit;}.toggle-wrapper>.collapse-toggle{left:0px;}.toggle-wrapper{height:1.5em;}#search{margin-left:0;}.content .impl-items .method,.content .impl-items>.type,.impl-items>.associatedconstant{display:flex;}.anchor{display:none !important;}h1.fqn{overflow:initial;}.theme-picker{left:10px;top:54px;z-index:1;}h4>.notable-traits{position:absolute;left:-22px;top:24px;}#titles>button>div.count{float:left;width:100%;}#titles{height:50px;}.sidebar.mobile{position:fixed;width:100%;margin-left:0;background-color:rgba(0,0,0,0);height:100%;}.sidebar{width:calc(100% + 30px);}.show-it{display:block;width:246px;}.show-it>.block.items{margin:8px 0;}.show-it>.block.items>ul{margin:0;}.show-it>.block.items>ul>li{text-align:center;margin:2px 0;}.show-it>.block.items>ul>li>a{font-size:21px;}#sidebar-filler{position:fixed;left:45px;width:calc(100% - 45px);top:0;height:45px;z-index:-1;border-bottom:1px solid;}.collapse-toggle{left:-20px;}.impl>.collapse-toggle{left:-10px;}#all-types{margin:10px;}#sidebar-toggle{top:100px;width:30px;font-size:1.5rem;text-align:center;padding:0;}#source-sidebar{z-index:11;}#main>.line-numbers{margin-top:0;}.notable-traits .notable-traits-tooltiptext{left:0;top:100%;}.help-button{display:none;}.search-container>div{width:calc(100% - 32px);}}@media print{nav.sub,.content .out-of-band,.collapse-toggle{display:none;}}@media (max-width:416px){#titles,#titles>button{height:73px;}#main{margin-top:100px;}#main>table:not(.table-display) td{word-break:break-word;width:50%;}.search-container>div{display:block;width:calc(100% - 37px);}#crate-search{width:100%;border-radius:4px;border:0;}#crate-search+.search-input{width:calc(100% + 71px);margin-left:-36px;}#theme-picker,#settings-menu{padding:5px;width:31px;height:31px;}#theme-picker{margin-top:-2px;}#settings-menu{top:7px;}}h3.notable{margin:0;margin-bottom:13px;font-size:19px;}kbd{display:inline-block;padding:3px 5px;font:15px monospace;line-height:10px;vertical-align:middle;border:solid 1px;border-radius:3px;box-shadow:inset 0 -1px 0;cursor:default;}.hidden-by-impl-hider,.hidden-by-usual-hider{display:none !important;}#implementations-list>h3>span.in-band{width:100%;}.table-display{width:100%;border:0;border-collapse:collapse;border-spacing:0;font-size:16px;}.table-display tr td:first-child{padding-right:0;}.table-display tr td:last-child{float:right;}.table-display .out-of-band{position:relative;font-size:19px;display:block;}#implementors-list>.impl-items .table-display .out-of-band{font-size:17px;}.table-display td:hover .anchor{display:block;top:2px;left:-5px;}#main>ul{padding-left:10px;}#main>ul>li{list-style:none;}.non-exhaustive{margin-bottom:1em;}div.children{padding-left:27px;display:none;}div.name{cursor:pointer;position:relative;margin-left:16px;}div.files>a{display:block;padding:0 3px;}div.files>a:hover,div.name:hover{background-color:#a14b4b;}div.name.expand+.children{display:block;}div.name::before{content:"\25B6";padding-left:4px;font-size:0.7em;position:absolute;left:-16px;top:4px;}div.name.expand::before{transform:rotate(90deg);left:-15px;top:2px;}.type-decl>pre>.toggle-wrapper.toggle-attributes.top-attr{margin-left:0 !important;}.type-decl>pre>.docblock.attributes.top-attr{margin-left:1.8em !important;}.type-decl>pre>.toggle-attributes{margin-left:2.2em;}.type-decl>pre>.docblock.attributes{margin-left:4em;} \ No newline at end of file + @font-face {font-family:'Fira Sans';font-style:normal;font-weight:400;src:local('Fira Sans'),url("FiraSans-Regular.woff2") format("woff2"),url("FiraSans-Regular.woff") format('woff');font-display:swap;}@font-face {font-family:'Fira Sans';font-style:normal;font-weight:500;src:local('Fira Sans Medium'),url("FiraSans-Medium.woff2") format("woff2"),url("FiraSans-Medium.woff") format('woff');font-display:swap;}@font-face {font-family:'Source Serif Pro';font-style:normal;font-weight:400;src:local('Source Serif Pro'),url("SourceSerifPro-Regular.ttf.woff") format('woff');font-display:swap;}@font-face {font-family:'Source Serif Pro';font-style:italic;font-weight:400;src:local('Source Serif Pro Italic'),url("SourceSerifPro-It.ttf.woff") format('woff');font-display:swap;}@font-face {font-family:'Source Serif Pro';font-style:normal;font-weight:700;src:local('Source Serif Pro Bold'),url("SourceSerifPro-Bold.ttf.woff") format('woff');font-display:swap;}@font-face {font-family:'Source Code Pro';font-style:normal;font-weight:400;src:url("SourceCodePro-Regular.woff") format('woff');font-display:swap;}@font-face {font-family:'Source Code Pro';font-style:normal;font-weight:600;src:url("SourceCodePro-Semibold.woff") format('woff');font-display:swap;}*{-webkit-box-sizing:border-box;-moz-box-sizing:border-box;box-sizing:border-box;}html{content:"";}@media (prefers-color-scheme:light){html{content:"light";}}@media (prefers-color-scheme:dark){html{content:"dark";}}body{font:16px/1.4 "Source Serif Pro",serif;margin:0;position:relative;padding:10px 15px 20px 15px;-webkit-font-feature-settings:"kern","liga";-moz-font-feature-settings:"kern","liga";font-feature-settings:"kern","liga";}h1{font-size:1.5em;}h2{font-size:1.4em;}h3{font-size:1.3em;}h1,h2,h3:not(.impl):not(.method):not(.type):not(.tymethod):not(.notable),h4:not(.method):not(.type):not(.tymethod):not(.associatedconstant){font-weight:500;margin:20px 0 15px 0;padding-bottom:6px;}h1.fqn{border-bottom:1px dashed;margin-top:0;}h1.fqn>.in-band>a:hover{text-decoration:underline;}h2,h3:not(.impl):not(.method):not(.type):not(.tymethod),h4:not(.method):not(.type):not(.tymethod):not(.associatedconstant){border-bottom:1px solid;}h3.impl,h3.method,h4.method,h3.type,h4.type,h4.associatedconstant{flex-basis:100%;font-weight:600;margin-top:16px;margin-bottom:10px;position:relative;}h3.impl,h3.method,h3.type{padding-left:15px;}h1,h2,h3,h4,.sidebar,a.source,.search-input,.content table td:first-child>a,.collapse-toggle,div.item-list .out-of-band,#source-sidebar,#sidebar-toggle,#main>ul.docblock>li>a{font-family:"Fira Sans",Arial,sans-serif;}.content ul.crate a.crate{font-size:16px/1.6;font-family:"Fira Sans",Arial,sans-serif;}ol,ul{padding-left:25px;}ul ul,ol ul,ul ol,ol ol{margin-bottom:.6em;}p{margin:0 0 .6em 0;}summary{outline:none;}code,pre,a.test-arrow{font-family:"Source Code Pro",monospace;}.docblock code,.docblock-short code{border-radius:3px;padding:0 0.1em;}.docblock pre code,.docblock-short pre code,.docblock code.spotlight{padding:0;padding-right:1ex;}.docblock code.spotlight :last-child{padding-bottom:0.6em;}pre{padding:14px;}.source .content pre{padding:20px;}img{max-width:100%;}li{position:relative;}.source .content{margin-top:50px;max-width:none;overflow:visible;margin-left:0px;min-width:70em;}nav.sub{font-size:16px;text-transform:uppercase;}.sidebar{width:200px;position:fixed;left:0;top:0;bottom:0;overflow:auto;}*{scrollbar-width:initial;}.sidebar{scrollbar-width:thin;}::-webkit-scrollbar{width:12px;}.sidebar::-webkit-scrollbar{width:8px;}::-webkit-scrollbar-track{-webkit-box-shadow:inset 0;}.sidebar .block>ul>li{margin-right:-10px;}.content,nav{max-width:960px;}.hidden{display:none !important;}.logo-container{height:100px;width:100px;position:relative;margin:20px auto;display:block;margin-top:10px;}.logo-container>img{max-width:100px;max-height:100px;position:absolute;left:50%;top:50%;transform:translate(-50%,-50%);display:block;}.sidebar .location{border:1px solid;font-size:17px;margin:30px 10px 20px 10px;text-align:center;word-wrap:break-word;}.sidebar .version{font-size:15px;text-align:center;border-bottom:1px solid;overflow-wrap:break-word;word-wrap:break-word;word-break:break-word;}.location:empty{border:none;}.location a:first-child{font-weight:500;}.block{padding:0;margin-bottom:14px;}.block h2,.block h3{margin-top:0;margin-bottom:8px;text-align:center;}.block ul,.block li{margin:0 10px;padding:0;list-style:none;}.block a{display:block;text-overflow:ellipsis;overflow:hidden;line-height:15px;padding:7px 5px;font-size:14px;font-weight:300;transition:border 500ms ease-out;}.sidebar-title{border-top:1px solid;border-bottom:1px solid;text-align:center;font-size:17px;margin-bottom:5px;}.sidebar-links{margin-bottom:15px;}.sidebar-links>a{padding-left:10px;width:100%;}.sidebar-menu{display:none;}.content{padding:15px 0;}.source .content pre.rust{white-space:pre;overflow:auto;padding-left:0;}.rustdoc:not(.source) .example-wrap{display:inline-flex;margin-bottom:10px;}.example-wrap{position:relative;width:100%;}.example-wrap>pre.line-number{overflow:initial;border:1px solid;border-top-left-radius:5px;border-bottom-left-radius:5px;padding:13px 8px;text-align:right;}.rustdoc:not(.source) .example-wrap>pre.rust{width:100%;overflow-x:auto;}.rustdoc:not(.source) .example-wrap>pre{margin:0;}#search{margin-left:230px;position:relative;}#results{position:absolute;right:0;left:0;overflow:auto;}#results>table{width:100%;table-layout:fixed;margin-bottom:40px;}.content pre.line-numbers{float:left;border:none;position:relative;-webkit-user-select:none;-moz-user-select:none;-ms-user-select:none;user-select:none;}.line-numbers span{cursor:pointer;}.docblock-short{overflow-wrap:anywhere;}.docblock-short p{display:inline;}.docblock-short p{overflow:hidden;text-overflow:ellipsis;margin:0;}.docblock-short code{white-space:pre-wrap;}.docblock h1,.docblock h2,.docblock h3,.docblock h4,.docblock h5{border-bottom:1px solid;}#main>.docblock h1{font-size:1.3em;}#main>.docblock h2{font-size:1.15em;}#main>.docblock h3,#main>.docblock h4,#main>.docblock h5{font-size:1em;}#main>h2+div,#main>h2+h3,#main>h3+div{display:none;flex-wrap:wrap;}.docblock h1{font-size:1em;}.docblock h2{font-size:0.95em;}.docblock h3,.docblock h4,.docblock h5{font-size:0.9em;}.docblock{margin-left:24px;position:relative;}.content .out-of-band{float:right;font-size:23px;margin:0px;padding:0px;font-weight:normal;}h3.impl>.out-of-band{font-size:21px;}h4.method>.out-of-band{font-size:19px;}h4>code,h3>code,.invisible>code{max-width:calc(100% - 41px);display:block;}.invisible{width:100%;display:inline-block;}.content .in-band{margin:0px;padding:0px;}.in-band>code{display:inline-block;}#main{position:relative;}#main>.since{top:inherit;font-family:"Fira Sans",Arial,sans-serif;}.content table:not(.table-display){border-spacing:0 5px;}.content td{vertical-align:top;}.content td:first-child{padding-right:20px;}.content td p:first-child{margin-top:0;}.content td h1,.content td h2{margin-left:0;font-size:1.1em;}.content tr:first-child td{border-top:0;}.docblock table{margin:.5em 0;width:calc(100% - 2px);border:1px dashed;}.docblock table td{padding:.5em;border:1px dashed;}.docblock table th{padding:.5em;text-align:left;border:1px solid;}.fields+table{margin-bottom:1em;}.content .item-list{list-style-type:none;padding:0;}.content .multi-column{-moz-column-count:5;-moz-column-gap:2.5em;-webkit-column-count:5;-webkit-column-gap:2.5em;column-count:5;column-gap:2.5em;}.content .multi-column li{width:100%;display:inline-block;}.content .method{font-size:1em;position:relative;}.content .method .where,.content .fn .where,.content .where.fmt-newline{display:block;font-size:0.8em;}.content .methods>div:not(.notable-traits){margin-left:40px;margin-bottom:15px;}.content .docblock>.impl-items{margin-left:20px;margin-top:-34px;}.content .docblock>.impl-items>h4{border-bottom:0;}.content .docblock>.impl-items .table-display{margin:0;}.content .docblock>.impl-items table td{padding:0;}.toggle-wrapper.marg-left>.collapse-toggle{left:-24px;}.content .docblock>.impl-items .table-display,.impl-items table td{border:none;}.content .item-info code{font-size:90%;}.content .item-info{position:relative;margin-left:33px;margin-top:-13px;}.sub-variant>div>.item-info{margin-top:initial;}.content .item-info::before{content:'⬑';font-size:25px;position:absolute;top:-6px;left:-19px;}.content .impl-items .method,.content .impl-items>.type,.impl-items>.associatedconstant{margin-left:20px;}.content .impl-items .docblock,.content .impl-items .item-info{margin-bottom:.6em;}.content .impl-items>.item-info{margin-left:40px;}.methods>.item-info,.content .impl-items>.item-info{margin-top:-8px;}.impl-items{flex-basis:100%;}#main>.item-info{margin-top:0;}nav:not(.sidebar){border-bottom:1px solid;padding-bottom:10px;margin-bottom:10px;}nav.main{padding:20px 0;text-align:center;}nav.main .current{border-top:1px solid;border-bottom:1px solid;}nav.main .separator{border:1px solid;display:inline-block;height:23px;margin:0 20px;}nav.sum{text-align:right;}nav.sub form{display:inline;}nav.sub,.content{margin-left:230px;}a{text-decoration:none;background:transparent;}.small-section-header:hover>.anchor{display:initial;}.in-band:hover>.anchor,.impl:hover>.anchor{display:inline-block;position:absolute;}.anchor{display:none;position:absolute;left:-7px;}.anchor.field{left:-5px;}.small-section-header>.anchor{left:-28px;padding-right:10px;}.anchor:before{content:'\2002\00a7\2002';}.docblock a:not(.srclink):not(.test-arrow):hover,.docblock-short a:not(.srclink):not(.test-arrow):hover,.item-info a{text-decoration:underline;}.invisible>.srclink,h4>code+.srclink,h3>code+.srclink{position:absolute;top:0;right:0;font-size:17px;font-weight:normal;}.block a.current.crate{font-weight:500;}.search-container{position:relative;}.search-container>div{display:inline-flex;width:calc(100% - 63px);}#crate-search{min-width:115px;margin-top:5px;padding:6px;padding-right:19px;flex:none;border:0;border-right:0;border-radius:4px 0 0 4px;outline:none;cursor:pointer;border-right:1px solid;-moz-appearance:none;-webkit-appearance:none;text-indent:0.01px;text-overflow:"";background-repeat:no-repeat;background-color:transparent;background-size:20px;background-position:calc(100% - 1px) 56%;}.search-container>.top-button{position:absolute;right:0;top:10px;}.search-input{-moz-box-sizing:border-box !important;box-sizing:border-box !important;outline:none;border:none;border-radius:1px;margin-top:5px;padding:10px 16px;font-size:17px;transition:border-color 300ms ease;transition:border-radius 300ms ease-in-out;transition:box-shadow 300ms ease-in-out;width:100%;}#crate-search+.search-input{border-radius:0 1px 1px 0;width:calc(100% - 32px);}.search-input:focus{border-radius:2px;border:0;outline:0;}.search-results .desc{white-space:nowrap;text-overflow:ellipsis;overflow:hidden;display:block;}.search-results a{display:block;}.content .search-results td:first-child{padding-right:0;width:50%;}.content .search-results td:first-child a{padding-right:10px;}.content .search-results td:first-child a:after{clear:both;content:"";display:block;}.content .search-results td:first-child a span{float:left;}tr.result span.primitive::after{content:' (primitive type)';font-style:italic;}tr.result span.keyword::after{content:' (keyword)';font-style:italic;}body.blur>:not(#help){filter:blur(8px);-webkit-filter:blur(8px);opacity:.7;}#help{width:100%;height:100vh;position:fixed;top:0;left:0;display:flex;justify-content:center;align-items:center;}#help>div{flex:0 0 auto;box-shadow:0 0 6px rgba(0,0,0,.2);width:550px;height:auto;border:1px solid;}#help dt{float:left;clear:left;display:block;margin-right:0.5rem;}#help>div>span{text-align:center;display:block;margin:10px 0;font-size:18px;border-bottom:1px solid #ccc;padding-bottom:4px;margin-bottom:6px;}#help dd{margin:5px 35px;}#help .infos{padding-left:0;}#help h1,#help h2{margin-top:0;}#help>div div{width:50%;float:left;padding:0 20px 20px 17px;;}.stab{display:table;border-width:1px;border-style:solid;padding:3px;margin-bottom:5px;font-size:90%;}.stab p{display:inline;}.stab summary{display:list-item;}.stab .emoji{font-size:1.5em;}.module-item .stab{border-radius:3px;display:inline-block;font-size:80%;line-height:1.2;margin-bottom:0;margin-right:.3em;padding:2px;vertical-align:text-bottom;}.module-item.unstable{opacity:0.65;}.since{font-weight:normal;font-size:initial;position:absolute;right:0;top:0;}.impl-items .since,.impl .since,.methods .since{flex-grow:0;padding-left:12px;padding-right:2px;position:initial;}.impl-items .srclink,.impl .srclink,.methods .srclink{flex-grow:0;font-size:17px;font-weight:normal;}.impl-items code,.impl code,.methods code{flex-grow:1;}.impl-items h4,h4.impl,h3.impl,.methods h3{display:flex;flex-basis:100%;font-size:16px;margin-bottom:12px;justify-content:space-between;}.variants_table{width:100%;}.variants_table tbody tr td:first-child{width:1%;}td.summary-column{width:100%;}.summary{padding-right:0px;}pre.rust .question-mark{font-weight:bold;}a.test-arrow{display:inline-block;position:absolute;padding:5px 10px 5px 10px;border-radius:5px;font-size:130%;top:5px;right:5px;z-index:1;}a.test-arrow:hover{text-decoration:none;}.section-header:hover a:before{position:absolute;left:-25px;padding-right:10px;content:'\2002\00a7\2002';}.section-header:hover a{text-decoration:none;}.section-header a{color:inherit;}.collapse-toggle{font-weight:300;position:absolute;left:-23px;top:0;}h3>.collapse-toggle,h4>.collapse-toggle{font-size:0.8em;top:5px;}.toggle-wrapper>.collapse-toggle{left:-24px;margin-top:0px;}.toggle-wrapper{position:relative;margin-top:0;}.toggle-wrapper.collapsed{height:25px;transition:height .2s;margin-bottom:.6em;}.collapse-toggle>.inner{display:inline-block;width:1.2ch;text-align:center;}.collapse-toggle.hidden-default{position:relative;margin-left:20px;}.since+.srclink{display:table-cell;padding-left:10px;}.item-spacer{width:100%;height:12px;}.out-of-band>span.since{position:initial;font-size:20px;margin-right:5px;}.toggle-wrapper>.collapse-toggle{left:0;}.variant+.toggle-wrapper+.docblock>p{margin-top:5px;}.sub-variant,.sub-variant>h3{margin-top:1px !important;}#main>.sub-variant>h3{font-size:15px;margin-left:25px;margin-bottom:5px;}.sub-variant>div{margin-left:20px;margin-bottom:10px;}.sub-variant>div>span{display:block;position:relative;}.toggle-label{display:inline-block;margin-left:4px;margin-top:3px;}.enum>.toggle-wrapper+.docblock,.struct>.toggle-wrapper+.docblock{margin-left:30px;margin-bottom:20px;margin-top:5px;}.docblock>.section-header:first-child{margin-left:15px;margin-top:0;}.docblock>.section-header:first-child:hover>a:before{left:-10px;}.enum>.collapsed,.struct>.collapsed{margin-bottom:25px;}#main>.variant,#main>.structfield{display:block;}.attributes{display:block;margin-top:0px !important;margin-right:0px;margin-bottom:0px !important;margin-left:30px;}.toggle-attributes.collapsed{margin-bottom:0;}.impl-items>.toggle-attributes{margin-left:20px;}.impl-items .attributes{font-weight:500;}:target>code{opacity:1;}.information{position:absolute;left:-25px;margin-top:7px;z-index:1;}.tooltip{position:relative;display:inline-block;cursor:pointer;}.tooltip::after{display:none;text-align:center;padding:5px 3px 3px 3px;border-radius:6px;margin-left:5px;font-size:16px;}.tooltip.ignore::after{content:"This example is not tested";}.tooltip.compile_fail::after{content:"This example deliberately fails to compile";}.tooltip.should_panic::after{content:"This example panics";}.tooltip.edition::after{content:"This code runs with edition " attr(data-edition);}.tooltip::before{content:" ";position:absolute;top:50%;left:16px;margin-top:-5px;border-width:5px;border-style:solid;display:none;}.tooltip:hover::before,.tooltip:hover::after{display:inline;}.tooltip.compile_fail,.tooltip.should_panic,.tooltip.ignore{font-weight:bold;font-size:20px;}.notable-traits-tooltip{display:inline-block;cursor:pointer;}.notable-traits:hover .notable-traits-tooltiptext,.notable-traits .notable-traits-tooltiptext.force-tooltip{display:inline-block;}.notable-traits .notable-traits-tooltiptext{display:none;padding:5px 3px 3px 3px;border-radius:6px;margin-left:5px;z-index:10;font-size:16px;cursor:default;position:absolute;border:1px solid;}.notable-traits-tooltip::after{content:"\00a0\00a0\00a0";}.notable-traits .notable,.notable-traits .docblock{margin:0;}.notable-traits .docblock code.content{margin:0;padding:0;font-size:20px;}pre.rust.rust-example-rendered{position:relative;}pre.rust{tab-size:4;-moz-tab-size:4;}.search-failed{text-align:center;margin-top:20px;}.search-failed>ul{text-align:left;max-width:570px;margin-left:auto;margin-right:auto;}#titles{height:35px;}#titles>button{float:left;width:33.3%;text-align:center;font-size:18px;cursor:pointer;border:0;border-top:2px solid;}#titles>button:not(:last-child){margin-right:1px;width:calc(33.3% - 1px);}#titles>button>div.count{display:inline-block;font-size:16px;}.notable-traits{cursor:pointer;z-index:2;margin-left:5px;}h4>.notable-traits{position:absolute;left:-44px;top:2px;}#all-types{text-align:center;border:1px solid;margin:0 10px;margin-bottom:10px;display:block;border-radius:7px;}#all-types>p{margin:5px 0;}#sidebar-toggle{position:fixed;top:30px;left:300px;z-index:10;padding:3px;border-top-right-radius:3px;border-bottom-right-radius:3px;cursor:pointer;font-weight:bold;transition:left .5s;font-size:1.2em;border:1px solid;border-left:0;}#source-sidebar{position:fixed;top:0;bottom:0;left:0;width:300px;z-index:1;overflow:auto;transition:left .5s;border-right:1px solid;}#source-sidebar>.title{font-size:1.5em;text-align:center;border-bottom:1px solid;margin-bottom:6px;}.theme-picker{position:absolute;left:211px;top:19px;}.theme-picker button{outline:none;}#settings-menu,.help-button{position:absolute;top:10px;}#settings-menu{right:0;outline:none;}.help-button{right:30px;font-family:"Fira Sans",Arial,sans-serif;text-align:center;font-size:17px;}#theme-picker,#settings-menu,.help-button{padding:4px;width:27px;height:29px;border:1px solid;border-radius:3px;cursor:pointer;}#theme-choices{display:none;position:absolute;left:0;top:28px;border:1px solid;border-radius:3px;z-index:1;cursor:pointer;}#theme-choices>button{border:none;width:100%;padding:4px 8px;text-align:center;background:rgba(0,0,0,0);}#theme-choices>button:not(:first-child){border-top:1px solid;}@media (min-width:701px){.information:first-child>.tooltip{margin-top:16px;}}@media (max-width:700px){body{padding-top:0px;}.rustdoc>.sidebar{height:45px;min-height:40px;margin:0;margin-left:-15px;padding:0 15px;position:static;z-index:11;}.sidebar>.location{float:right;margin:0px;margin-top:2px;padding:3px 10px 1px 10px;min-height:39px;background:inherit;text-align:left;font-size:24px;}.sidebar .location:empty{padding:0;}.sidebar .logo-container{width:35px;height:35px;margin-top:5px;margin-bottom:5px;float:left;margin-left:50px;}.sidebar .logo-container>img{max-width:35px;max-height:35px;}.sidebar-menu{position:fixed;z-index:10;font-size:2rem;cursor:pointer;width:45px;left:0;text-align:center;display:block;border-bottom:1px solid;border-right:1px solid;height:45px;}.rustdoc.source>.sidebar>.sidebar-menu{display:none;}.sidebar-elems{position:fixed;z-index:1;left:0;top:45px;bottom:0;overflow-y:auto;border-right:1px solid;display:none;}.sidebar>.block.version{border-bottom:none;margin-top:12px;margin-bottom:0;}nav.sub{width:calc(100% - 32px);float:right;}.content{margin-left:0px;}#main,#search{margin-top:45px;padding:0;}.content .in-band{width:100%;}.content h4>.out-of-band{position:inherit;}.toggle-wrapper>.collapse-toggle{left:0px;}.toggle-wrapper{height:1.5em;}#search{margin-left:0;}.content .impl-items .method,.content .impl-items>.type,.impl-items>.associatedconstant{display:flex;}.anchor{display:none !important;}h1.fqn{overflow:initial;}.theme-picker{left:10px;top:54px;z-index:1;}h4>.notable-traits{position:absolute;left:-22px;top:24px;}#titles>button>div.count{float:left;width:100%;}#titles{height:50px;}.sidebar.mobile{position:fixed;width:100%;margin-left:0;background-color:rgba(0,0,0,0);height:100%;}.sidebar.mobile>div.version{overflow:hidden;max-height:33px;}.sidebar{width:calc(100% + 30px);}.show-it{display:block;width:246px;}.show-it>.block.items{margin:8px 0;}.show-it>.block.items>ul{margin:0;}.show-it>.block.items>ul>li{text-align:center;margin:2px 0;}.show-it>.block.items>ul>li>a{font-size:21px;}#sidebar-filler{position:fixed;left:45px;width:calc(100% - 45px);top:0;height:45px;z-index:-1;border-bottom:1px solid;}.collapse-toggle{left:-20px;}.impl>.collapse-toggle{left:-10px;}#all-types{margin:10px;}#sidebar-toggle{top:100px;width:30px;font-size:1.5rem;text-align:center;padding:0;}#source-sidebar{z-index:11;}#main>.line-numbers{margin-top:0;}.notable-traits .notable-traits-tooltiptext{left:0;top:100%;}.help-button{display:none;}.search-container>div{width:calc(100% - 32px);}}@media print{nav.sub,.content .out-of-band,.collapse-toggle{display:none;}}@media (max-width:464px){#titles,#titles>button{height:73px;}#main,#search{margin-top:100px;}#main>table:not(.table-display) td{word-break:break-word;width:50%;}.search-container>div{display:block;width:calc(100% - 37px);}#crate-search{width:100%;border-radius:4px;border:0;}#crate-search+.search-input{width:calc(100% + 71px);margin-left:-36px;}#theme-picker,#settings-menu{padding:5px;width:31px;height:31px;}#theme-picker{margin-top:-2px;}#settings-menu{top:7px;}.docblock{margin-left:12px;}}h3.notable{margin:0;margin-bottom:13px;font-size:19px;}kbd{display:inline-block;padding:3px 5px;font:15px monospace;line-height:10px;vertical-align:middle;border:solid 1px;border-radius:3px;box-shadow:inset 0 -1px 0;cursor:default;}.hidden-by-impl-hider,.hidden-by-usual-hider{display:none !important;}#implementations-list>h3>span.in-band{width:100%;}.table-display{width:100%;border:0;border-collapse:collapse;border-spacing:0;font-size:16px;}.table-display tr td:first-child{padding-right:0;}.table-display tr td:last-child{float:right;}.table-display .out-of-band{position:relative;font-size:19px;display:block;}#implementors-list>.impl-items .table-display .out-of-band{font-size:17px;}.table-display td:hover .anchor{display:block;top:2px;left:-5px;}#main>ul{padding-left:10px;}#main>ul>li{list-style:none;}.non-exhaustive{margin-bottom:1em;}div.children{padding-left:27px;display:none;}div.name{cursor:pointer;position:relative;margin-left:16px;}div.files>a{display:block;padding:0 3px;}div.files>a:hover,div.name:hover{background-color:#a14b4b;}div.name.expand+.children{display:block;}div.name::before{content:"\25B6";padding-left:4px;font-size:0.7em;position:absolute;left:-16px;top:4px;}div.name.expand::before{transform:rotate(90deg);left:-15px;top:2px;}.type-decl>pre>.toggle-wrapper.toggle-attributes.top-attr{margin-left:0 !important;}.type-decl>pre>.docblock.attributes.top-attr{margin-left:1.8em !important;}.type-decl>pre>.toggle-attributes{margin-left:2.2em;}.type-decl>pre>.docblock.attributes{margin-left:4em;} \ No newline at end of file diff --git a/search-index.js b/search-index.js index b361bd3..36f8c6e 100644 --- a/search-index.js +++ b/search-index.js @@ -1,13 +1,13 @@ var searchIndex = JSON.parse('{\ -"cfg_if":{"doc":"A macro for defining #[cfg] if-else statements.","i":[[14,"cfg_if","cfg_if","The main macro provided by this crate. See crate …",null,null]],"p":[]},\ -"delog":{"doc":"Compile-time configurable deferred logging (for printf()…","i":[[4,"Level","delog","An enum representing the available verbosity levels of …",null,null],[13,"Error","","The \\\"error\\\" level.",0,null],[13,"Warn","","The \\\"warn\\\" level.",0,null],[13,"Info","","The \\\"info\\\" level.",0,null],[13,"Debug","","The \\\"debug\\\" level.",0,null],[13,"Trace","","The \\\"trace\\\" level.",0,null],[4,"LevelFilter","","An enum representing the available verbosity level …",null,null],[13,"Off","","A level lower than all log levels.",1,null],[13,"Error","","Corresponds to the Error log level.",1,null],[13,"Warn","","Corresponds to the Warn log level.",1,null],[13,"Info","","Corresponds to the Info log level.",1,null],[13,"Debug","","Corresponds to the Debug log level.",1,null],[13,"Trace","","Corresponds to the Trace log level.",1,null],[3,"Record","","The \\\"payload\\\" of a log message.",null,null],[0,"hex","","Convenient Display and other traits for binary data.",null,null],[8,"Unsigned","delog::hex","A type that specifies an unsigned integer.",null,null],[18,"N","","The actual number.",2,null],[3,"U1","","A type that represents the integer 1.",null,null],[8,"Separator","","A type that specifies a separator str.",null,null],[18,"SEPARATOR","","The actual separator str.",3,null],[3,"HexStr","","Zero-sized wrapper newtype, allowing grouping bytes in …",null,null],[12,"value","","The value to be formatted.",4,null],[5,"HexStr","","Explicitly construct a newtype to format with.",null,[[],[["hexstr",3],["unsigned",8],["sized",8],["separator",8]]]],[0,"render","delog","The default, minimal renderer, and some helper functions.",null,null],[5,"render_arguments","delog::render","For some reason, there seems to be no existing method to …",null,[[["arguments",3]]]],[5,"render_record","","Render record, based on feature flags.",null,[[["record",3]]]],[3,"DefaultRenderer","","Renders just the record.args().",null,null],[5,"default","","The default, minimal renderer.",null,[[],["defaultrenderer",3]]],[3,"RipgrepRenderer","","Renders the record.args(), prefixed by level, target, and …",null,null],[8,"Delogger","delog","Semi-abstract characterization of the deferred loggers …",null,null],[10,"buffer","","the underlying buffer",5,[[]]],[10,"claimed","","How many characters were claimed so far.",5,[[],["atomicusize",3]]],[10,"flush","","Call the flusher.",5,[[]]],[10,"render","","Actually render the arguments (via internal static …",5,[[["record",3]]]],[11,"capacity","","Capacity of circular buffer.",5,[[]]],[3,"Statistics","","Statistics on logger usage.",null,null],[12,"attempts","","How often was one of the logging macros called.",6,null],[12,"successes","","How often was one of the logging macros called without …",6,null],[12,"flushes","","How often was the flusher called.",6,null],[12,"read","","How many bytes were flushed so far.",6,null],[12,"written","","How many bytes were logged so far.",6,null],[8,"State","","Trait for either state or statistics of loggers.",null,null],[10,"attempts","","How often was one of the logging macros called.",7,[[]]],[10,"successes","","How often was one of the logging macros called without …",7,[[]]],[10,"flushes","","How often was the flusher called.",7,[[]]],[10,"read","","How many bytes were flushed so far.",7,[[]]],[10,"written","","How many bytes were logged so far.",7,[[]]],[8,"TryLog","","Fallible, panic-free version of the log::Log trait.",null,null],[10,"try_log","","Fallible logging call (fails when buffer is full)",8,[[["record",3]],["result",4]]],[8,"TryLogWithStatistics","","TryLog with some usage statistics on top.",null,null],[11,"statistics","","Read out statistics on logger usage.",9,[[],["statistics",3]]],[5,"dequeue","","The core \\\"read from circular buffer\\\" method. Marked …",null,[[]]],[5,"enqueue","","The core \\\"write to circular buffer\\\" method. Marked unsafe …",null,[[["record",3]]]],[5,"try_enqueue","","The fallible \\\"write to circular buffer\\\" method. Marked …",null,[[["record",3]],["result",4]]],[8,"Flusher","","A way to pass on logs, user supplied.",null,null],[10,"flush","","Implementor must handle passed log &str in some hopefully …",10,[[]]],[8,"Renderer","","A way to format logs, user supplied.",null,null],[10,"render","","Implementor must render record into buf, returning the …",11,[[["record",3]]]],[5,"logger","","Returns a reference to the logger (as TryLogWithStatistics…",null,[[],["option",4]]],[14,"hex_str","","Compactly format byte arrays and slices as hexadecimals.",null,null],[14,"hexstr","","More compactly format byte arrays and slices as …",null,null],[14,"try_log","","Fallible (ungated) version of log!.",null,null],[14,"generate_macros","","Generate logging macros that can be gated by library.",null,null],[14,"delog","","Generate a deferred logger with specified capacity and …",null,null],[11,"from","","",0,[[]]],[11,"borrow","","",0,[[]]],[11,"borrow_mut","","",0,[[]]],[11,"try_from","","",0,[[],["result",4]]],[11,"into","","",0,[[]]],[11,"try_into","","",0,[[],["result",4]]],[11,"type_id","","",0,[[],["typeid",3]]],[11,"from","","",1,[[]]],[11,"borrow","","",1,[[]]],[11,"borrow_mut","","",1,[[]]],[11,"try_from","","",1,[[],["result",4]]],[11,"into","","",1,[[]]],[11,"try_into","","",1,[[],["result",4]]],[11,"type_id","","",1,[[],["typeid",3]]],[11,"from","","",12,[[]]],[11,"borrow","","",12,[[]]],[11,"borrow_mut","","",12,[[]]],[11,"try_from","","",12,[[],["result",4]]],[11,"into","","",12,[[]]],[11,"try_into","","",12,[[],["result",4]]],[11,"type_id","","",12,[[],["typeid",3]]],[11,"from","delog::hex","",13,[[]]],[11,"borrow","","",13,[[]]],[11,"borrow_mut","","",13,[[]]],[11,"try_from","","",13,[[],["result",4]]],[11,"into","","",13,[[]]],[11,"try_into","","",13,[[],["result",4]]],[11,"type_id","","",13,[[],["typeid",3]]],[11,"from","","",4,[[]]],[11,"borrow","","",4,[[]]],[11,"borrow_mut","","",4,[[]]],[11,"try_from","","",4,[[],["result",4]]],[11,"into","","",4,[[]]],[11,"try_into","","",4,[[],["result",4]]],[11,"type_id","","",4,[[],["typeid",3]]],[11,"from","delog","",6,[[]]],[11,"borrow","","",6,[[]]],[11,"borrow_mut","","",6,[[]]],[11,"try_from","","",6,[[],["result",4]]],[11,"into","","",6,[[]]],[11,"try_into","","",6,[[],["result",4]]],[11,"type_id","","",6,[[],["typeid",3]]],[11,"from","delog::render","",14,[[]]],[11,"borrow","","",14,[[]]],[11,"borrow_mut","","",14,[[]]],[11,"try_from","","",14,[[],["result",4]]],[11,"into","","",14,[[]]],[11,"try_into","","",14,[[],["result",4]]],[11,"type_id","","",14,[[],["typeid",3]]],[11,"from","","",15,[[]]],[11,"borrow","","",15,[[]]],[11,"borrow_mut","","",15,[[]]],[11,"try_from","","",15,[[],["result",4]]],[11,"into","","",15,[[]]],[11,"try_into","","",15,[[],["result",4]]],[11,"type_id","","",15,[[],["typeid",3]]],[11,"partial_cmp","delog","",0,[[["levelfilter",4]],[["ordering",4],["option",4]]]],[11,"lt","","",0,[[["levelfilter",4]]]],[11,"le","","",0,[[["levelfilter",4]]]],[11,"gt","","",0,[[["levelfilter",4]]]],[11,"ge","","",0,[[["levelfilter",4]]]],[11,"partial_cmp","","",1,[[["level",4]],[["ordering",4],["option",4]]]],[11,"lt","","",1,[[["level",4]]]],[11,"le","","",1,[[["level",4]]]],[11,"gt","","",1,[[["level",4]]]],[11,"ge","","",1,[[["level",4]]]],[11,"partial_cmp","","",0,[[["level",4]],[["ordering",4],["option",4]]]],[11,"lt","","",0,[[["level",4]]]],[11,"le","","",0,[[["level",4]]]],[11,"gt","","",0,[[["level",4]]]],[11,"ge","","",0,[[["level",4]]]],[11,"partial_cmp","","",1,[[["levelfilter",4]],[["ordering",4],["option",4]]]],[11,"lt","","",1,[[["levelfilter",4]]]],[11,"le","","",1,[[["levelfilter",4]]]],[11,"gt","","",1,[[["levelfilter",4]]]],[11,"ge","","",1,[[["levelfilter",4]]]],[11,"cmp","","",0,[[["level",4]],["ordering",4]]],[11,"cmp","","",1,[[["levelfilter",4]],["ordering",4]]],[11,"hash","","",1,[[]]],[11,"hash","","",0,[[]]],[11,"eq","","",1,[[["level",4]]]],[11,"eq","","",1,[[["levelfilter",4]]]],[11,"eq","","",0,[[["levelfilter",4]]]],[11,"eq","","",0,[[["level",4]]]],[11,"fmt","","",1,[[["formatter",3]],[["result",4],["error",3]]]],[11,"fmt","","",0,[[["formatter",3]],[["result",4],["error",3]]]],[11,"fmt","","",0,[[["formatter",3]],[["result",4],["error",3]]]],[11,"fmt","","",1,[[["formatter",3]],[["result",4],["error",3]]]],[11,"fmt","","",12,[[["formatter",3]],[["result",4],["error",3]]]],[11,"from_str","","",0,[[],[["result",4],["level",4]]]],[11,"from_str","","",1,[[],[["result",4],["levelfilter",4]]]],[11,"clone","","",12,[[],["record",3]]],[11,"clone","","",1,[[],["levelfilter",4]]],[11,"clone","","",0,[[],["level",4]]],[11,"render","delog::render","",14,[[["record",3]]]],[11,"render","","",15,[[["record",3]]]],[11,"fmt","delog::hex","",4,[[["formatter",3]],[["error",3],["result",4]]]],[11,"fmt","delog","",6,[[["formatter",3]],["result",6]]],[11,"fmt","delog::hex","",4,[[["formatter",3]],[["error",3],["result",4]]]],[11,"fmt","","",4,[[["formatter",3]],[["error",3],["result",4]]]],[11,"fmt","","",4,[[["formatter",3]],[["error",3],["result",4]]]],[11,"clone","delog","",6,[[],["statistics",3]]],[11,"clone","delog::render","",14,[[],["defaultrenderer",3]]],[11,"clone","","",15,[[],["ripgreprenderer",3]]],[11,"max","delog","Returns the most verbose logging level.",0,[[],["level",4]]],[11,"to_level_filter","","Converts the Level to the equivalent LevelFilter.",0,[[],["levelfilter",4]]],[11,"as_str","","Returns the string representation of the Level.",0,[[]]],[11,"max","","Returns the most verbose logging level filter.",1,[[],["levelfilter",4]]],[11,"to_level","","Converts self to the equivalent Level.",1,[[],[["level",4],["option",4]]]],[11,"as_str","","Returns the string representation of the LevelFilter.",1,[[]]],[11,"builder","","Returns a new builder.",12,[[],["recordbuilder",3]]],[11,"args","","The message body.",12,[[],["arguments",3]]],[11,"metadata","","Metadata about the log directive.",12,[[],["metadata",3]]],[11,"level","","The verbosity level of the message.",12,[[],["level",4]]],[11,"target","","The name of the target of the directive.",12,[[]]],[11,"module_path","","The module path of the message.",12,[[],["option",4]]],[11,"module_path_static","","The module path of the message, if it is a \'static string.",12,[[],["option",4]]],[11,"file","","The source file containing the message.",12,[[],["option",4]]],[11,"file_static","","The module path of the message, if it is a \'static string.",12,[[],["option",4]]],[11,"line","","The line containing the message.",12,[[],["option",4]]],[11,"capacity","","Capacity of circular buffer.",5,[[]]],[11,"statistics","","Read out statistics on logger usage.",9,[[],["statistics",3]]]],"p":[[4,"Level"],[4,"LevelFilter"],[8,"Unsigned"],[8,"Separator"],[3,"HexStr"],[8,"Delogger"],[3,"Statistics"],[8,"State"],[8,"TryLog"],[8,"TryLogWithStatistics"],[8,"Flusher"],[8,"Renderer"],[3,"Record"],[3,"U1"],[3,"DefaultRenderer"],[3,"RipgrepRenderer"]]},\ -"flexiber":{"doc":"flexiberImplementation of the BER-TLV serialization …","i":[[24,"Decodable","flexiber","Derive the Decodable trait on a struct.",null,null],[24,"Encodable","","Derive the Encodable trait on a struct.",null,null],[3,"Decoder","","BER-TLV decoder.",null,null],[3,"Encoder","","BER-TLV encoder.",null,null],[3,"Error","","Error type.",null,null],[4,"ErrorKind","","Error type.",null,null],[13,"Failed","","Operation failed due to previous error",0,null],[13,"InvalidClass","","Class has more than 2 bytes",0,null],[12,"value","flexiber::ErrorKind","",1,null],[13,"InvalidTag","flexiber","Invalid tag",0,null],[12,"byte","flexiber::ErrorKind","Raw byte value of the tag",2,null],[13,"InvalidLength","flexiber","Length greater than u16::MAX",0,null],[13,"Length","","Incorrect length for a given field",0,null],[12,"tag","flexiber::ErrorKind","Tag type of the value being decoded",3,null],[13,"Overflow","flexiber","Integer overflow occurred (library bug!)",0,null],[13,"Overlength","","Message is longer than BER-TLV\'s limits support",0,null],[13,"TrailingData","","Undecoded trailing data at end of message",0,null],[12,"decoded","flexiber::ErrorKind","Length of the decoded data",4,null],[12,"remaining","","Total length of the remaining data left in the buffer",4,null],[13,"Truncated","flexiber","Unexpected end-of-message/nested field when decoding",0,null],[13,"Underlength","","Encoded message is shorter than the expected length (i.e. …",0,null],[12,"expected","flexiber::ErrorKind","Expected length",5,null],[12,"actual","","Actual length",5,null],[13,"UnexpectedTag","flexiber","Unexpected tag",0,null],[12,"expected","flexiber::ErrorKind","Tag the decoder was expecting (if there is a single such …",6,null],[12,"actual","","Actual tag encountered in the message",6,null],[13,"UnsupportedTagSize","flexiber","Tag does not fit in 3 bytes",0,null],[6,"Result","","Result type.",null,null],[3,"Length","","BER-TLV-encoded length.",null,null],[3,"SimpleTag","","These are tags like in SIMPLE-TLV.",null,null],[3,"Slice","","Slice of at most Length::max() bytes.",null,null],[4,"Class","","Class of BER tag.",null,null],[13,"Universal","","",7,null],[13,"Application","","",7,null],[13,"Context","","",7,null],[13,"Private","","",7,null],[3,"Tag","","The tag field consists of a single byte encoding a tag …",null,null],[12,"class","","",8,null],[12,"constructed","","",8,null],[12,"number","","",8,null],[8,"TagLike","","This is the common trait that types to be used as tags …",null,null],[10,"embedding","","To stick with one Error type, make sure the tag type can …",9,[[],["tag",3]]],[11,"assert_eq","","Assert that this [Tag] matches the provided expected tag.",9,[[],["result",6]]],[11,"with_value","","Ergonomic way to get a TaggedValue for a given tag and …",9,[[],["taggedvalue",3]]],[6,"TaggedSlice","","Raw BER-TLV data object TaggedValue>.",null,null],[3,"TaggedValue","","BER-TLV data object.",null,null],[8,"Container","","Multiple encodables in a container.",null,null],[10,"fields","","Call the provided function with a slice of [Encodable] …",10,[[],["result",6]]],[8,"Decodable","","Decoding trait.",null,null],[10,"decode","","Attempt to decode this message using the provided decoder.",11,[[["decoder",3]],["result",6]]],[11,"from_bytes","","Parse Self from the provided byte slice.",11,[[],["result",6]]],[8,"Encodable","","Encoding trait.",null,null],[10,"encoded_length","","Compute the length of this value in bytes when encoded as …",12,[[],[["length",3],["result",6]]]],[10,"encode","","Encode this value as BER-TLV using the provided [Encoder].",12,[[["encoder",3]],["result",6]]],[11,"encode_to_slice","","Encode this value to the provided byte slice, returning a …",12,[[],["result",6]]],[8,"Tagged","","Types with an associated BER-TLV [Tag].",null,null],[10,"tag","","The tag",13,[[],["tag",3]]],[14,"try_debug","","Fallible version of debug!.",null,null],[14,"try_error","","Fallible version of error!.",null,null],[14,"try_info","","Fallible version of info!.",null,null],[14,"try_trace","","Fallible version of trace!.",null,null],[14,"try_warn","","Fallible version of warn!.",null,null],[14,"log","","Local version of log!.",null,null],[14,"debug","","Local version of debug!.",null,null],[14,"error","","Local version of error!.",null,null],[14,"info","","Local version of info!.",null,null],[14,"trace","","Local version of trace!.",null,null],[14,"warn","","Local version of warn!.",null,null],[14,"log_now","","Immediate version of log!.",null,null],[14,"debug_now","","Immediate version of debug!.",null,null],[14,"error_now","","Immediate version of error!.",null,null],[14,"info_now","","Immediate version of info!.",null,null],[14,"trace_now","","Immediate version of trace!.",null,null],[14,"warn_now","","Immediate version of warn!.",null,null],[14,"try_log_now","","Fallible immediate version of log!.",null,null],[14,"try_debug_now","","Fallible immediate version of debug!.",null,null],[14,"try_error_now","","Fallible immediate version of error!.",null,null],[14,"try_info_now","","Fallible immediate version of info!.",null,null],[14,"try_trace_now","","Fallible immediate version of trace!.",null,null],[14,"try_warn_now","","Fallible immediate version of warn!.",null,null],[11,"from","","",14,[[]]],[11,"borrow","","",14,[[]]],[11,"borrow_mut","","",14,[[]]],[11,"try_from","","",14,[[],["result",4]]],[11,"into","","",14,[[]]],[11,"try_into","","",14,[[],["result",4]]],[11,"type_id","","",14,[[],["typeid",3]]],[11,"from","","",15,[[]]],[11,"borrow","","",15,[[]]],[11,"borrow_mut","","",15,[[]]],[11,"try_from","","",15,[[],["result",4]]],[11,"into","","",15,[[]]],[11,"try_into","","",15,[[],["result",4]]],[11,"type_id","","",15,[[],["typeid",3]]],[11,"from","","",16,[[]]],[11,"borrow","","",16,[[]]],[11,"borrow_mut","","",16,[[]]],[11,"try_from","","",16,[[],["result",4]]],[11,"into","","",16,[[]]],[11,"try_into","","",16,[[],["result",4]]],[11,"type_id","","",16,[[],["typeid",3]]],[11,"from","","",0,[[]]],[11,"borrow","","",0,[[]]],[11,"borrow_mut","","",0,[[]]],[11,"try_from","","",0,[[],["result",4]]],[11,"into","","",0,[[]]],[11,"try_into","","",0,[[],["result",4]]],[11,"type_id","","",0,[[],["typeid",3]]],[11,"from","","",17,[[]]],[11,"borrow","","",17,[[]]],[11,"borrow_mut","","",17,[[]]],[11,"try_from","","",17,[[],["result",4]]],[11,"into","","",17,[[]]],[11,"try_into","","",17,[[],["result",4]]],[11,"type_id","","",17,[[],["typeid",3]]],[11,"from","","",18,[[]]],[11,"borrow","","",18,[[]]],[11,"borrow_mut","","",18,[[]]],[11,"try_from","","",18,[[],["result",4]]],[11,"into","","",18,[[]]],[11,"try_into","","",18,[[],["result",4]]],[11,"type_id","","",18,[[],["typeid",3]]],[11,"from","","",19,[[]]],[11,"borrow","","",19,[[]]],[11,"borrow_mut","","",19,[[]]],[11,"try_from","","",19,[[],["result",4]]],[11,"into","","",19,[[]]],[11,"try_into","","",19,[[],["result",4]]],[11,"type_id","","",19,[[],["typeid",3]]],[11,"from","","",7,[[]]],[11,"borrow","","",7,[[]]],[11,"borrow_mut","","",7,[[]]],[11,"try_from","","",7,[[],["result",4]]],[11,"into","","",7,[[]]],[11,"try_into","","",7,[[],["result",4]]],[11,"type_id","","",7,[[],["typeid",3]]],[11,"from","","",8,[[]]],[11,"borrow","","",8,[[]]],[11,"borrow_mut","","",8,[[]]],[11,"try_from","","",8,[[],["result",4]]],[11,"into","","",8,[[]]],[11,"try_into","","",8,[[],["result",4]]],[11,"type_id","","",8,[[],["typeid",3]]],[11,"from","","",20,[[]]],[11,"borrow","","",20,[[]]],[11,"borrow_mut","","",20,[[]]],[11,"try_from","","",20,[[],["result",4]]],[11,"into","","",20,[[]]],[11,"try_into","","",20,[[],["result",4]]],[11,"type_id","","",20,[[],["typeid",3]]],[11,"embedding","","",18,[[],["tag",3]]],[11,"embedding","","",8,[[],["tag",3]]],[11,"decode","","",17,[[["decoder",3]],[["length",3],["result",6]]]],[11,"decode","","",18,[[["decoder",3]],["result",6]]],[11,"decode","","",8,[[["decoder",3]],["result",6]]],[11,"decode","","",21,[[["decoder",3]],["result",6]]],[11,"encoded_length","","",17,[[],[["length",3],["result",6]]]],[11,"encode","","",17,[[["encoder",3]],["result",6]]],[11,"encoded_length","","",18,[[],[["length",3],["result",6]]]],[11,"encode","","",18,[[["encoder",3]],["result",6]]],[11,"encoded_length","","",8,[[],[["length",3],["result",6]]]],[11,"encode","","",8,[[["encoder",3]],["result",6]]],[11,"encoded_length","","",20,[[],[["length",3],["result",6]]]],[11,"encode","","",20,[[["encoder",3]],["result",6]]],[11,"encoded_length","","",21,[[],[["length",3],["result",6]]]],[11,"encode","","",21,[[["encoder",3]],["result",6]]],[11,"from","","",14,[[],["decoder",3]]],[11,"from","","",16,[[["errorkind",4]],["error",3]]],[11,"from","","",16,[[["infallible",4]],["error",3]]],[11,"from","","",17,[[],["length",3]]],[11,"from","","",17,[[],["length",3]]],[11,"fmt","","",14,[[["formatter",3]],["result",6]]],[11,"fmt","","",15,[[["formatter",3]],["result",6]]],[11,"fmt","","",16,[[["formatter",3]],["result",6]]],[11,"fmt","","",0,[[["formatter",3]],["result",6]]],[11,"fmt","","",17,[[["formatter",3]],["result",6]]],[11,"fmt","","",19,[[["formatter",3]],["result",6]]],[11,"fmt","","",7,[[["formatter",3]],["result",6]]],[11,"fmt","","",8,[[["formatter",3]],["result",6]]],[11,"fmt","","",20,[[["formatter",3]],["result",6]]],[11,"fmt","","",16,[[["formatter",3]],["result",6]]],[11,"fmt","","",0,[[["formatter",3]],["result",6]]],[11,"fmt","","",17,[[["formatter",3]],["result",6]]],[11,"fmt","","",8,[[["formatter",3]],["result",6]]],[11,"eq","","",16,[[["error",3]]]],[11,"ne","","",16,[[["error",3]]]],[11,"eq","","",0,[[["errorkind",4]]]],[11,"ne","","",0,[[["errorkind",4]]]],[11,"eq","","",17,[[["length",3]]]],[11,"ne","","",17,[[["length",3]]]],[11,"eq","","",18,[[["simpletag",3]]]],[11,"ne","","",18,[[["simpletag",3]]]],[11,"eq","","",19,[[["slice",3]]]],[11,"ne","","",19,[[["slice",3]]]],[11,"eq","","",7,[[["class",4]]]],[11,"eq","","",8,[[["tag",3]]]],[11,"ne","","",8,[[["tag",3]]]],[11,"eq","","",20,[[["taggedvalue",3]]]],[11,"ne","","",20,[[["taggedvalue",3]]]],[11,"cmp","","",17,[[["length",3]],["ordering",4]]],[11,"partial_cmp","","",17,[[["length",3]],[["option",4],["ordering",4]]]],[11,"lt","","",17,[[["length",3]]]],[11,"le","","",17,[[["length",3]]]],[11,"gt","","",17,[[["length",3]]]],[11,"ge","","",17,[[["length",3]]]],[11,"add","","",17,[[],["result",6]]],[11,"add","","",17,[[],["result",6]]],[11,"add","","",17,[[],["result",6]]],[11,"add","","",17,[[],["result",6]]],[11,"add","","",22,[[["length",3]]]],[11,"try_from","","",17,[[],[["length",3],["result",6]]]],[11,"try_from","","",17,[[],[["length",3],["result",6]]]],[11,"try_from","","",18,[[],["result",6]]],[11,"try_from","","",7,[[],["result",6]]],[11,"try_from","","",8,[[],["result",6]]],[11,"try_from","","",8,[[],["result",6]]],[11,"as_ref","","",19,[[]]],[11,"clone","","",16,[[],["error",3]]],[11,"clone","","",0,[[],["errorkind",4]]],[11,"clone","","",17,[[],["length",3]]],[11,"clone","","",18,[[],["simpletag",3]]],[11,"clone","","",19,[[],["slice",3]]],[11,"clone","","",7,[[],["class",4]]],[11,"clone","","",8,[[],["tag",3]]],[11,"clone","","",20,[[],["taggedvalue",3]]],[11,"default","","",17,[[],["length",3]]],[11,"new","","Create a new decoder for the given byte slice.",14,[[]]],[11,"decode","","Decode a value which impls the [Decodable] trait.",14,[[],[["result",6],["decodable",8]]]],[11,"decode_tagged_value","","Decode a TaggedValue with tag checked to be as expected, …",14,[[["decodable",8],["taglike",8]],[["decodable",8],["result",6]]]],[11,"decode_tagged_slice","","Decode a TaggedSlice with tag checked to be as expected, …",14,[[["decodable",8],["taglike",8]],["result",6]]],[11,"error","","Return an error with the given [ErrorKind], annotating it …",14,[[["errorkind",4]],["result",6]]],[11,"is_failed","","Did the decoding operation fail due to an error?",14,[[]]],[11,"finish","","Finish decoding, returning the given value if there is no …",14,[[],["result",6]]],[11,"is_finished","","Have we decoded all of the bytes in this [Decoder]?",14,[[]]],[11,"new","","Create a new encoder with the given byte slice as a …",15,[[]]],[11,"encode","","Encode a value which impls the [Encodable] trait.",15,[[],["result",6]]],[11,"error","","Return an error with the given [ErrorKind], annotating it …",15,[[["errorkind",4]],["result",6]]],[11,"is_failed","","Did the decoding operation fail due to an error?",15,[[]]],[11,"finish","","Finish encoding to the buffer, returning a slice …",15,[[],["result",6]]],[11,"encode_tagged_collection","","Encode a collection of values which impl the [Encodable] …",15,[[["tag",3]],["result",6]]],[11,"encode_untagged_collection","","Encode a collection of values which impl the [Encodable] …",15,[[],["result",6]]],[11,"new","","Create a new [Error]",16,[[["errorkind",4],["length",3]],["error",3]]],[11,"kind","","Get the [ErrorKind] which occurred.",16,[[],["errorkind",4]]],[11,"position","","Get the position inside of the message where the error …",16,[[],[["length",3],["option",4]]]],[11,"nested","","For errors occurring inside of a nested message, extend …",16,[[["length",3]]]],[11,"at","","Annotate an [ErrorKind] with context about where it …",0,[[["length",3]],["error",3]]],[11,"zero","","Return a length of 0.",17,[[]]],[11,"max","","Get the maximum length supported by BER-TLV: 65,535.",17,[[]]],[11,"to_usize","","Convert length to usize.",17,[[]]],[11,"new","","Create a new [Slice], ensuring that the provided slice …",19,[[],["result",6]]],[11,"as_bytes","","Borrow the inner byte slice",19,[[]]],[11,"length","","Get the [Length] of this [Slice]",19,[[],["length",3]]],[11,"is_empty","","Is this [Slice] empty?",19,[[]]],[18,"BOOLEAN","","",8,null],[18,"INTEGER","","",8,null],[18,"BIT_STRING","","",8,null],[18,"OCTET_STRING","","",8,null],[18,"NULL","","",8,null],[18,"OBJECT_IDENTIFIER","","",8,null],[18,"UTF8_STRING","","",8,null],[18,"PRINTABLE_STRING","","",8,null],[18,"UTC_TIME","","",8,null],[18,"GENERALIZED_TIME","","",8,null],[18,"SEQUENCE","","",8,null],[18,"SET","","",8,null],[11,"from","","",8,[[["class",4]]]],[11,"universal","","",8,[[]]],[11,"application","","",8,[[]]],[11,"context","","",8,[[]]],[11,"private","","",8,[[]]],[11,"constructed","","",8,[[]]],[11,"assert_eq","","Assert that this [Tag] matches the provided expected tag.",9,[[],["result",6]]],[11,"with_value","","Ergonomic way to get a TaggedValue for a given tag and …",9,[[],["taggedvalue",3]]],[11,"new","","",20,[[]]],[11,"tag","","",20,[[]]],[11,"from","","Create a new tagged slice, checking lengths.",20,[[],["result",6]]],[11,"as_bytes","","Borrow the inner byte slice.",20,[[]]],[11,"length","","Get the length of the inner byte slice.",20,[[],["length",3]]],[11,"is_empty","","Is the inner byte slice empty?",20,[[]]],[11,"decode_nested","","Decode nested values, creating a new [Decoder] for the …",20,[[],["result",6]]],[11,"from","","Create a new tagged slice, checking lengths.",21,[[],["result",6]]],[11,"as_bytes","","Borrow the inner byte slice.",21,[[]]],[11,"length","","Get the length of the inner byte slice.",21,[[],["length",3]]],[11,"is_empty","","Is the inner byte slice empty?",21,[[]]],[11,"decode_nested","","Decode nested values, creating a new [Decoder] for the …",21,[[],["result",6]]],[11,"from_bytes","","Parse Self from the provided byte slice.",11,[[],["result",6]]],[11,"encode_to_slice","","Encode this value to the provided byte slice, returning a …",12,[[],["result",6]]]],"p":[[4,"ErrorKind"],[13,"InvalidClass"],[13,"InvalidTag"],[13,"Length"],[13,"TrailingData"],[13,"Underlength"],[13,"UnexpectedTag"],[4,"Class"],[3,"Tag"],[8,"TagLike"],[8,"Container"],[8,"Decodable"],[8,"Encodable"],[8,"Tagged"],[3,"Decoder"],[3,"Encoder"],[3,"Error"],[3,"Length"],[3,"SimpleTag"],[3,"Slice"],[3,"TaggedValue"],[6,"TaggedSlice"],[6,"Result"]]},\ -"flexiber_derive":{"doc":"Custom derive support for the flexiber crate","i":[[24,"Decodable","flexiber_derive","Derive the Decodable trait on a struct.",null,null],[24,"Encodable","","Derive the Encodable trait on a struct.",null,null]],"p":[]},\ -"log":{"doc":"A lightweight logging facade.","i":[[4,"Level","log","An enum representing the available verbosity levels of …",null,null],[13,"Error","","The \\\"error\\\" level.",0,null],[13,"Warn","","The \\\"warn\\\" level.",0,null],[13,"Info","","The \\\"info\\\" level.",0,null],[13,"Debug","","The \\\"debug\\\" level.",0,null],[13,"Trace","","The \\\"trace\\\" level.",0,null],[11,"max","","Returns the most verbose logging level.",0,[[],["level",4]]],[11,"to_level_filter","","Converts the Level to the equivalent LevelFilter.",0,[[],["levelfilter",4]]],[11,"as_str","","Returns the string representation of the Level.",0,[[]]],[4,"LevelFilter","","An enum representing the available verbosity level …",null,null],[13,"Off","","A level lower than all log levels.",1,null],[13,"Error","","Corresponds to the Error log level.",1,null],[13,"Warn","","Corresponds to the Warn log level.",1,null],[13,"Info","","Corresponds to the Info log level.",1,null],[13,"Debug","","Corresponds to the Debug log level.",1,null],[13,"Trace","","Corresponds to the Trace log level.",1,null],[11,"max","","Returns the most verbose logging level filter.",1,[[],["levelfilter",4]]],[11,"to_level","","Converts self to the equivalent Level.",1,[[],[["option",4],["level",4]]]],[11,"as_str","","Returns the string representation of the LevelFilter.",1,[[]]],[3,"Record","","The \\\"payload\\\" of a log message.",null,null],[11,"builder","","Returns a new builder.",2,[[],["recordbuilder",3]]],[11,"args","","The message body.",2,[[],["arguments",3]]],[11,"metadata","","Metadata about the log directive.",2,[[],["metadata",3]]],[11,"level","","The verbosity level of the message.",2,[[],["level",4]]],[11,"target","","The name of the target of the directive.",2,[[]]],[11,"module_path","","The module path of the message.",2,[[],["option",4]]],[11,"module_path_static","","The module path of the message, if it is a \'static string.",2,[[],["option",4]]],[11,"file","","The source file containing the message.",2,[[],["option",4]]],[11,"file_static","","The module path of the message, if it is a \'static string.",2,[[],["option",4]]],[11,"line","","The line containing the message.",2,[[],["option",4]]],[3,"RecordBuilder","","Builder for Record.",null,null],[11,"new","","Construct new RecordBuilder.",3,[[],["recordbuilder",3]]],[11,"args","","Set args.",3,[[["arguments",3]],["recordbuilder",3]]],[11,"metadata","","Set metadata. Construct a Metadata object with …",3,[[["metadata",3]],["recordbuilder",3]]],[11,"level","","Set Metadata::level.",3,[[["level",4]],["recordbuilder",3]]],[11,"target","","Set Metadata::target",3,[[],["recordbuilder",3]]],[11,"module_path","","Set module_path",3,[[["option",4]],["recordbuilder",3]]],[11,"module_path_static","","Set module_path to a \'static string",3,[[["option",4]],["recordbuilder",3]]],[11,"file","","Set file",3,[[["option",4]],["recordbuilder",3]]],[11,"file_static","","Set file to a \'static string.",3,[[["option",4]],["recordbuilder",3]]],[11,"line","","Set line",3,[[["option",4]],["recordbuilder",3]]],[11,"build","","Invoke the builder and return a Record",3,[[],["record",3]]],[3,"Metadata","","Metadata about a log message.",null,null],[11,"builder","","Returns a new builder.",4,[[],["metadatabuilder",3]]],[11,"level","","The verbosity level of the message.",4,[[],["level",4]]],[11,"target","","The name of the target of the directive.",4,[[]]],[3,"MetadataBuilder","","Builder for Metadata.",null,null],[11,"new","","Construct a new MetadataBuilder.",5,[[],["metadatabuilder",3]]],[11,"level","","Setter for level.",5,[[["level",4]],["metadatabuilder",3]]],[11,"target","","Setter for target.",5,[[],["metadatabuilder",3]]],[11,"build","","Returns a Metadata object.",5,[[],["metadata",3]]],[8,"Log","","A trait encapsulating the operations required of a logger.",null,null],[10,"enabled","","Determines if a log message with the specified metadata …",6,[[["metadata",3]]]],[10,"log","","Logs the Record.",6,[[["record",3]]]],[10,"flush","","Flushes any buffered records.",6,[[]]],[5,"set_max_level","","Sets the global maximum log level.",null,[[["levelfilter",4]]]],[5,"max_level","","Returns the current maximum log level.",null,[[],["levelfilter",4]]],[5,"set_logger","","Sets the global logger to a &\'static Log.",null,[[["log",8]],[["result",4],["setloggererror",3]]]],[5,"set_logger_racy","","A thread-unsafe version of set_logger.",null,[[["log",8]],[["result",4],["setloggererror",3]]]],[3,"SetLoggerError","","The type returned by set_logger if set_logger has already …",null,null],[3,"ParseLevelError","","The type returned by from_str when the string doesn\'t …",null,null],[5,"logger","","Returns a reference to the logger.",null,[[],["log",8]]],[17,"STATIC_MAX_LEVEL","","The statically resolved maximum log level.",null,null],[14,"log","","The standard logging macro.",null,null],[14,"error","","Logs a message at the error level.",null,null],[14,"warn","","Logs a message at the warn level.",null,null],[14,"info","","Logs a message at the info level.",null,null],[14,"debug","","Logs a message at the debug level.",null,null],[14,"trace","","Logs a message at the trace level.",null,null],[14,"log_enabled","","Determines if a message logged at the specified level in …",null,null],[11,"from","","",0,[[]]],[11,"borrow","","",0,[[]]],[11,"borrow_mut","","",0,[[]]],[11,"try_from","","",0,[[],["result",4]]],[11,"into","","",0,[[]]],[11,"try_into","","",0,[[],["result",4]]],[11,"type_id","","",0,[[],["typeid",3]]],[11,"from","","",1,[[]]],[11,"borrow","","",1,[[]]],[11,"borrow_mut","","",1,[[]]],[11,"try_from","","",1,[[],["result",4]]],[11,"into","","",1,[[]]],[11,"try_into","","",1,[[],["result",4]]],[11,"type_id","","",1,[[],["typeid",3]]],[11,"from","","",2,[[]]],[11,"borrow","","",2,[[]]],[11,"borrow_mut","","",2,[[]]],[11,"try_from","","",2,[[],["result",4]]],[11,"into","","",2,[[]]],[11,"try_into","","",2,[[],["result",4]]],[11,"type_id","","",2,[[],["typeid",3]]],[11,"from","","",3,[[]]],[11,"borrow","","",3,[[]]],[11,"borrow_mut","","",3,[[]]],[11,"try_from","","",3,[[],["result",4]]],[11,"into","","",3,[[]]],[11,"try_into","","",3,[[],["result",4]]],[11,"type_id","","",3,[[],["typeid",3]]],[11,"from","","",4,[[]]],[11,"borrow","","",4,[[]]],[11,"borrow_mut","","",4,[[]]],[11,"try_from","","",4,[[],["result",4]]],[11,"into","","",4,[[]]],[11,"try_into","","",4,[[],["result",4]]],[11,"type_id","","",4,[[],["typeid",3]]],[11,"from","","",5,[[]]],[11,"borrow","","",5,[[]]],[11,"borrow_mut","","",5,[[]]],[11,"try_from","","",5,[[],["result",4]]],[11,"into","","",5,[[]]],[11,"try_into","","",5,[[],["result",4]]],[11,"type_id","","",5,[[],["typeid",3]]],[11,"from","","",7,[[]]],[11,"borrow","","",7,[[]]],[11,"borrow_mut","","",7,[[]]],[11,"try_from","","",7,[[],["result",4]]],[11,"into","","",7,[[]]],[11,"try_into","","",7,[[],["result",4]]],[11,"type_id","","",7,[[],["typeid",3]]],[11,"from","","",8,[[]]],[11,"borrow","","",8,[[]]],[11,"borrow_mut","","",8,[[]]],[11,"try_from","","",8,[[],["result",4]]],[11,"into","","",8,[[]]],[11,"try_into","","",8,[[],["result",4]]],[11,"type_id","","",8,[[],["typeid",3]]],[11,"fmt","","",0,[[["formatter",3]],["result",6]]],[11,"fmt","","",1,[[["formatter",3]],["result",6]]],[11,"fmt","","",2,[[["formatter",3]],["result",6]]],[11,"fmt","","",3,[[["formatter",3]],["result",6]]],[11,"fmt","","",4,[[["formatter",3]],["result",6]]],[11,"fmt","","",5,[[["formatter",3]],["result",6]]],[11,"fmt","","",7,[[["formatter",3]],["result",6]]],[11,"fmt","","",8,[[["formatter",3]],["result",6]]],[11,"fmt","","",0,[[["formatter",3]],["result",6]]],[11,"fmt","","",1,[[["formatter",3]],["result",6]]],[11,"fmt","","",7,[[["formatter",3]],["result",6]]],[11,"fmt","","",8,[[["formatter",3]],["result",6]]],[11,"eq","","",0,[[["level",4]]]],[11,"eq","","",0,[[["levelfilter",4]]]],[11,"eq","","",1,[[["levelfilter",4]]]],[11,"eq","","",1,[[["level",4]]]],[11,"eq","","",4,[[["metadata",3]]]],[11,"ne","","",4,[[["metadata",3]]]],[11,"eq","","",5,[[["metadatabuilder",3]]]],[11,"ne","","",5,[[["metadatabuilder",3]]]],[11,"eq","","",8,[[["parselevelerror",3]]]],[11,"ne","","",8,[[["parselevelerror",3]]]],[11,"cmp","","",0,[[["level",4]],["ordering",4]]],[11,"cmp","","",1,[[["levelfilter",4]],["ordering",4]]],[11,"cmp","","",4,[[["metadata",3]],["ordering",4]]],[11,"cmp","","",5,[[["metadatabuilder",3]],["ordering",4]]],[11,"partial_cmp","","",0,[[["level",4]],[["option",4],["ordering",4]]]],[11,"lt","","",0,[[["level",4]]]],[11,"le","","",0,[[["level",4]]]],[11,"gt","","",0,[[["level",4]]]],[11,"ge","","",0,[[["level",4]]]],[11,"partial_cmp","","",0,[[["levelfilter",4]],[["option",4],["ordering",4]]]],[11,"lt","","",0,[[["levelfilter",4]]]],[11,"le","","",0,[[["levelfilter",4]]]],[11,"gt","","",0,[[["levelfilter",4]]]],[11,"ge","","",0,[[["levelfilter",4]]]],[11,"partial_cmp","","",1,[[["levelfilter",4]],[["option",4],["ordering",4]]]],[11,"lt","","",1,[[["levelfilter",4]]]],[11,"le","","",1,[[["levelfilter",4]]]],[11,"gt","","",1,[[["levelfilter",4]]]],[11,"ge","","",1,[[["levelfilter",4]]]],[11,"partial_cmp","","",1,[[["level",4]],[["option",4],["ordering",4]]]],[11,"lt","","",1,[[["level",4]]]],[11,"le","","",1,[[["level",4]]]],[11,"gt","","",1,[[["level",4]]]],[11,"ge","","",1,[[["level",4]]]],[11,"partial_cmp","","",4,[[["metadata",3]],[["option",4],["ordering",4]]]],[11,"lt","","",4,[[["metadata",3]]]],[11,"le","","",4,[[["metadata",3]]]],[11,"gt","","",4,[[["metadata",3]]]],[11,"ge","","",4,[[["metadata",3]]]],[11,"partial_cmp","","",5,[[["metadatabuilder",3]],[["option",4],["ordering",4]]]],[11,"lt","","",5,[[["metadatabuilder",3]]]],[11,"le","","",5,[[["metadatabuilder",3]]]],[11,"gt","","",5,[[["metadatabuilder",3]]]],[11,"ge","","",5,[[["metadatabuilder",3]]]],[11,"hash","","",0,[[]]],[11,"hash","","",1,[[]]],[11,"hash","","",4,[[]]],[11,"hash","","",5,[[]]],[11,"from_str","","",0,[[],[["level",4],["result",4]]]],[11,"from_str","","",1,[[],[["levelfilter",4],["result",4]]]],[11,"clone","","",0,[[],["level",4]]],[11,"clone","","",1,[[],["levelfilter",4]]],[11,"clone","","",2,[[],["record",3]]],[11,"clone","","",4,[[],["metadata",3]]]],"p":[[4,"Level"],[4,"LevelFilter"],[3,"Record"],[3,"RecordBuilder"],[3,"Metadata"],[3,"MetadataBuilder"],[8,"Log"],[3,"SetLoggerError"],[3,"ParseLevelError"]]},\ -"proc_macro2":{"doc":"A wrapper around the procedural macro API of the …","i":[[0,"token_stream","proc_macro2","Public implementation details for the TokenStream type, …",null,null],[3,"IntoIter","proc_macro2::token_stream","An iterator over TokenStream\'s TokenTrees.",null,null],[3,"TokenStream","proc_macro2","An abstract stream of tokens, or more concretely a …",null,null],[3,"LexError","","Error returned from TokenStream::from_str.",null,null],[11,"new","","Returns an empty TokenStream containing no token trees.",0,[[],["tokenstream",3]]],[11,"is_empty","","Checks if this TokenStream is empty.",0,[[]]],[3,"Span","","A region of source code, along with macro expansion …",null,null],[11,"call_site","","The span of the invocation of the current procedural …",1,[[],["span",3]]],[11,"mixed_site","","The span located at the invocation of the procedural …",1,[[],["span",3]]],[11,"resolved_at","","Creates a new span with the same line/column information …",1,[[["span",3]],["span",3]]],[11,"located_at","","Creates a new span with the same name resolution behavior …",1,[[["span",3]],["span",3]]],[11,"unwrap","","Convert proc_macro2::Span to proc_macro::Span.",1,[[],["span",3]]],[11,"join","","Create a new span encompassing self and other.",1,[[["span",3]],[["span",3],["option",4]]]],[4,"TokenTree","","A single token or a delimited sequence of token trees …",null,null],[13,"Group","","A token stream surrounded by bracket delimiters.",2,null],[13,"Ident","","An identifier.",2,null],[13,"Punct","","A single punctuation character (+, ,, $, etc.).",2,null],[13,"Literal","","A literal character (\'a\'), string (\\\"hello\\\"), number (2.3…",2,null],[11,"span","","Returns the span of this tree, delegating to the span …",2,[[],["span",3]]],[11,"set_span","","Configures the span for only this token.",2,[[["span",3]]]],[3,"Group","","A delimited token stream.",null,null],[4,"Delimiter","","Describes how a sequence of token trees is delimited.",null,null],[13,"Parenthesis","","( ... )",3,null],[13,"Brace","","{ ... }",3,null],[13,"Bracket","","[ ... ]",3,null],[13,"None","","Ø ... Ø",3,null],[11,"new","","Creates a new Group with the given delimiter and token …",4,[[["tokenstream",3],["delimiter",4]],["group",3]]],[11,"delimiter","","Returns the delimiter of this Group",4,[[],["delimiter",4]]],[11,"stream","","Returns the TokenStream of tokens that are delimited in …",4,[[],["tokenstream",3]]],[11,"span","","Returns the span for the delimiters of this token stream, …",4,[[],["span",3]]],[11,"span_open","","Returns the span pointing to the opening delimiter of …",4,[[],["span",3]]],[11,"span_close","","Returns the span pointing to the closing delimiter of …",4,[[],["span",3]]],[11,"set_span","","Configures the span for this Group\'s delimiters, but not …",4,[[["span",3]]]],[3,"Punct","","An Punct is an single punctuation character like +, - or #…",null,null],[4,"Spacing","","Whether an Punct is followed immediately by another Punct …",null,null],[13,"Alone","","E.g. + is Alone in + =, +ident or +().",5,null],[13,"Joint","","E.g. + is Joint in += or \' is Joint in \'#.",5,null],[11,"new","","Creates a new Punct from the given character and spacing.",6,[[["spacing",4]],["punct",3]]],[11,"as_char","","Returns the value of this punctuation character as char.",6,[[]]],[11,"spacing","","Returns the spacing of this punctuation character, …",6,[[],["spacing",4]]],[11,"span","","Returns the span for this punctuation character.",6,[[],["span",3]]],[11,"set_span","","Configure the span for this punctuation character.",6,[[["span",3]]]],[3,"Ident","","A word of Rust code, which may be a keyword or legal …",null,null],[11,"new","","Creates a new Ident with the given string as well as the …",7,[[["span",3]],["ident",3]]],[11,"span","","Returns the span of this Ident.",7,[[],["span",3]]],[11,"set_span","","Configures the span of this Ident, possibly changing its …",7,[[["span",3]]]],[3,"Literal","","A literal string (\\\"hello\\\"), byte string (b\\\"hello\\\"), …",null,null],[11,"u8_suffixed","","Creates a new suffixed integer literal with the specified …",8,[[],["literal",3]]],[11,"u16_suffixed","","Creates a new suffixed integer literal with the specified …",8,[[],["literal",3]]],[11,"u32_suffixed","","Creates a new suffixed integer literal with the specified …",8,[[],["literal",3]]],[11,"u64_suffixed","","Creates a new suffixed integer literal with the specified …",8,[[],["literal",3]]],[11,"u128_suffixed","","Creates a new suffixed integer literal with the specified …",8,[[],["literal",3]]],[11,"usize_suffixed","","Creates a new suffixed integer literal with the specified …",8,[[],["literal",3]]],[11,"i8_suffixed","","Creates a new suffixed integer literal with the specified …",8,[[],["literal",3]]],[11,"i16_suffixed","","Creates a new suffixed integer literal with the specified …",8,[[],["literal",3]]],[11,"i32_suffixed","","Creates a new suffixed integer literal with the specified …",8,[[],["literal",3]]],[11,"i64_suffixed","","Creates a new suffixed integer literal with the specified …",8,[[],["literal",3]]],[11,"i128_suffixed","","Creates a new suffixed integer literal with the specified …",8,[[],["literal",3]]],[11,"isize_suffixed","","Creates a new suffixed integer literal with the specified …",8,[[],["literal",3]]],[11,"u8_unsuffixed","","Creates a new unsuffixed integer literal with the …",8,[[],["literal",3]]],[11,"u16_unsuffixed","","Creates a new unsuffixed integer literal with the …",8,[[],["literal",3]]],[11,"u32_unsuffixed","","Creates a new unsuffixed integer literal with the …",8,[[],["literal",3]]],[11,"u64_unsuffixed","","Creates a new unsuffixed integer literal with the …",8,[[],["literal",3]]],[11,"u128_unsuffixed","","Creates a new unsuffixed integer literal with the …",8,[[],["literal",3]]],[11,"usize_unsuffixed","","Creates a new unsuffixed integer literal with the …",8,[[],["literal",3]]],[11,"i8_unsuffixed","","Creates a new unsuffixed integer literal with the …",8,[[],["literal",3]]],[11,"i16_unsuffixed","","Creates a new unsuffixed integer literal with the …",8,[[],["literal",3]]],[11,"i32_unsuffixed","","Creates a new unsuffixed integer literal with the …",8,[[],["literal",3]]],[11,"i64_unsuffixed","","Creates a new unsuffixed integer literal with the …",8,[[],["literal",3]]],[11,"i128_unsuffixed","","Creates a new unsuffixed integer literal with the …",8,[[],["literal",3]]],[11,"isize_unsuffixed","","Creates a new unsuffixed integer literal with the …",8,[[],["literal",3]]],[11,"f64_unsuffixed","","Creates a new unsuffixed floating-point literal.",8,[[],["literal",3]]],[11,"f64_suffixed","","Creates a new suffixed floating-point literal.",8,[[],["literal",3]]],[11,"f32_unsuffixed","","Creates a new unsuffixed floating-point literal.",8,[[],["literal",3]]],[11,"f32_suffixed","","Creates a new suffixed floating-point literal.",8,[[],["literal",3]]],[11,"string","","String literal.",8,[[],["literal",3]]],[11,"character","","Character literal.",8,[[],["literal",3]]],[11,"byte_string","","Byte string literal.",8,[[],["literal",3]]],[11,"span","","Returns the span encompassing this literal.",8,[[],["span",3]]],[11,"set_span","","Configures the span associated for this literal.",8,[[["span",3]]]],[11,"subspan","","Returns a Span that is a subset of self.span() containing …",8,[[["rangebounds",8]],[["span",3],["option",4]]]],[11,"from","proc_macro2::token_stream","",9,[[]]],[11,"into","","",9,[[]]],[11,"into_iter","","",9,[[]]],[11,"to_owned","","",9,[[]]],[11,"clone_into","","",9,[[]]],[11,"borrow","","",9,[[]]],[11,"borrow_mut","","",9,[[]]],[11,"try_from","","",9,[[],["result",4]]],[11,"try_into","","",9,[[],["result",4]]],[11,"type_id","","",9,[[],["typeid",3]]],[11,"from","proc_macro2","",0,[[]]],[11,"into","","",0,[[]]],[11,"to_owned","","",0,[[]]],[11,"clone_into","","",0,[[]]],[11,"to_string","","",0,[[],["string",3]]],[11,"borrow","","",0,[[]]],[11,"borrow_mut","","",0,[[]]],[11,"try_from","","",0,[[],["result",4]]],[11,"try_into","","",0,[[],["result",4]]],[11,"type_id","","",0,[[],["typeid",3]]],[11,"from","","",10,[[]]],[11,"into","","",10,[[]]],[11,"to_string","","",10,[[],["string",3]]],[11,"borrow","","",10,[[]]],[11,"borrow_mut","","",10,[[]]],[11,"try_from","","",10,[[],["result",4]]],[11,"try_into","","",10,[[],["result",4]]],[11,"type_id","","",10,[[],["typeid",3]]],[11,"from","","",1,[[]]],[11,"into","","",1,[[]]],[11,"to_owned","","",1,[[]]],[11,"clone_into","","",1,[[]]],[11,"borrow","","",1,[[]]],[11,"borrow_mut","","",1,[[]]],[11,"try_from","","",1,[[],["result",4]]],[11,"try_into","","",1,[[],["result",4]]],[11,"type_id","","",1,[[],["typeid",3]]],[11,"from","","",2,[[]]],[11,"into","","",2,[[]]],[11,"to_owned","","",2,[[]]],[11,"clone_into","","",2,[[]]],[11,"to_string","","",2,[[],["string",3]]],[11,"borrow","","",2,[[]]],[11,"borrow_mut","","",2,[[]]],[11,"try_from","","",2,[[],["result",4]]],[11,"try_into","","",2,[[],["result",4]]],[11,"type_id","","",2,[[],["typeid",3]]],[11,"from","","",4,[[]]],[11,"into","","",4,[[]]],[11,"to_owned","","",4,[[]]],[11,"clone_into","","",4,[[]]],[11,"to_string","","",4,[[],["string",3]]],[11,"borrow","","",4,[[]]],[11,"borrow_mut","","",4,[[]]],[11,"try_from","","",4,[[],["result",4]]],[11,"try_into","","",4,[[],["result",4]]],[11,"type_id","","",4,[[],["typeid",3]]],[11,"from","","",3,[[]]],[11,"into","","",3,[[]]],[11,"to_owned","","",3,[[]]],[11,"clone_into","","",3,[[]]],[11,"borrow","","",3,[[]]],[11,"borrow_mut","","",3,[[]]],[11,"try_from","","",3,[[],["result",4]]],[11,"try_into","","",3,[[],["result",4]]],[11,"type_id","","",3,[[],["typeid",3]]],[11,"from","","",6,[[]]],[11,"into","","",6,[[]]],[11,"to_owned","","",6,[[]]],[11,"clone_into","","",6,[[]]],[11,"to_string","","",6,[[],["string",3]]],[11,"borrow","","",6,[[]]],[11,"borrow_mut","","",6,[[]]],[11,"try_from","","",6,[[],["result",4]]],[11,"try_into","","",6,[[],["result",4]]],[11,"type_id","","",6,[[],["typeid",3]]],[11,"from","","",5,[[]]],[11,"into","","",5,[[]]],[11,"to_owned","","",5,[[]]],[11,"clone_into","","",5,[[]]],[11,"borrow","","",5,[[]]],[11,"borrow_mut","","",5,[[]]],[11,"try_from","","",5,[[],["result",4]]],[11,"try_into","","",5,[[],["result",4]]],[11,"type_id","","",5,[[],["typeid",3]]],[11,"from","","",7,[[]]],[11,"into","","",7,[[]]],[11,"to_owned","","",7,[[]]],[11,"clone_into","","",7,[[]]],[11,"to_string","","",7,[[],["string",3]]],[11,"borrow","","",7,[[]]],[11,"borrow_mut","","",7,[[]]],[11,"try_from","","",7,[[],["result",4]]],[11,"try_into","","",7,[[],["result",4]]],[11,"type_id","","",7,[[],["typeid",3]]],[11,"from","","",8,[[]]],[11,"into","","",8,[[]]],[11,"to_owned","","",8,[[]]],[11,"clone_into","","",8,[[]]],[11,"to_string","","",8,[[],["string",3]]],[11,"borrow","","",8,[[]]],[11,"borrow_mut","","",8,[[]]],[11,"try_from","","",8,[[],["result",4]]],[11,"try_into","","",8,[[],["result",4]]],[11,"type_id","","",8,[[],["typeid",3]]],[11,"from","","",1,[[["span",3]],["span",3]]],[11,"from","","",0,[[["tokenstream",3]],["tokenstream",3]]],[11,"from","","",0,[[["tokentree",4]]]],[11,"from","","",2,[[["group",3]],["tokentree",4]]],[11,"from","","",2,[[["ident",3]],["tokentree",4]]],[11,"from","","",2,[[["punct",3]],["tokentree",4]]],[11,"from","","",2,[[["literal",3]],["tokentree",4]]],[11,"extend","","",0,[[["intoiterator",8]]]],[11,"extend","","",0,[[["intoiterator",8]]]],[11,"into_iter","","",0,[[],["intoiter",3]]],[11,"next","proc_macro2::token_stream","",9,[[],[["tokentree",4],["option",4]]]],[11,"clone","proc_macro2","",0,[[],["tokenstream",3]]],[11,"clone","","",1,[[],["span",3]]],[11,"clone","","",2,[[],["tokentree",4]]],[11,"clone","","",4,[[],["group",3]]],[11,"clone","","",3,[[],["delimiter",4]]],[11,"clone","","",6,[[],["punct",3]]],[11,"clone","","",5,[[],["spacing",4]]],[11,"clone","","",7,[[],["ident",3]]],[11,"clone","","",8,[[],["literal",3]]],[11,"clone","proc_macro2::token_stream","",9,[[],["intoiter",3]]],[11,"default","proc_macro2","",0,[[]]],[11,"cmp","","",7,[[["ident",3]],["ordering",4]]],[11,"eq","","",3,[[["delimiter",4]]]],[11,"eq","","",5,[[["spacing",4]]]],[11,"eq","","",7,[[["ident",3]]]],[11,"eq","","",7,[[]]],[11,"partial_cmp","","",7,[[["ident",3]],[["option",4],["ordering",4]]]],[11,"fmt","","",0,[[["formatter",3]],["result",6]]],[11,"fmt","","",10,[[["formatter",3]],["result",6]]],[11,"fmt","","",1,[[["formatter",3]],["result",6]]],[11,"fmt","","",2,[[["formatter",3]],["result",6]]],[11,"fmt","","",3,[[["formatter",3]],["result",6]]],[11,"fmt","","",4,[[["formatter",3]],["result",6]]],[11,"fmt","","",5,[[["formatter",3]],["result",6]]],[11,"fmt","","",6,[[["formatter",3]],["result",6]]],[11,"fmt","","",7,[[["formatter",3]],["result",6]]],[11,"fmt","","",8,[[["formatter",3]],["result",6]]],[11,"fmt","proc_macro2::token_stream","",9,[[["formatter",3]],["result",6]]],[11,"fmt","proc_macro2","",0,[[["formatter",3]],["result",6]]],[11,"fmt","","",10,[[["formatter",3]],["result",6]]],[11,"fmt","","",2,[[["formatter",3]],["result",6]]],[11,"fmt","","",4,[[["formatter",3]],["result",6]]],[11,"fmt","","",6,[[["formatter",3]],["result",6]]],[11,"fmt","","",7,[[["formatter",3]],["result",6]]],[11,"fmt","","",8,[[["formatter",3]],["result",6]]],[11,"hash","","",7,[[]]],[11,"from_str","","",0,[[],[["tokenstream",3],["lexerror",3],["result",4]]]],[11,"from_iter","","",0,[[["intoiterator",8]]]],[11,"from_iter","","",0,[[["intoiterator",8]]]]],"p":[[3,"TokenStream"],[3,"Span"],[4,"TokenTree"],[4,"Delimiter"],[3,"Group"],[4,"Spacing"],[3,"Punct"],[3,"Ident"],[3,"Literal"],[3,"IntoIter"],[3,"LexError"]]},\ -"quote":{"doc":"github crates-io docs-rs","i":[[8,"TokenStreamExt","quote","TokenStream extension trait with methods for appending …",null,null],[10,"append","","For use by ToTokens implementations.",0,[[]]],[10,"append_all","","For use by ToTokens implementations.",0,[[]]],[10,"append_separated","","For use by ToTokens implementations.",0,[[]]],[10,"append_terminated","","For use by ToTokens implementations.",0,[[]]],[8,"IdentFragment","","Specialized formatting trait used by format_ident!.",null,null],[10,"fmt","","Format this value as an identifier fragment.",1,[[["formatter",3]],["result",6]]],[11,"span","","Span associated with this IdentFragment.",1,[[],[["option",4],["span",3]]]],[8,"ToTokens","","Types that can be interpolated inside a quote! invocation.",null,null],[10,"to_tokens","","Write self to the given TokenStream.",2,[[["tokenstream",3]]]],[11,"to_token_stream","","Convert self directly into a TokenStream object.",2,[[],["tokenstream",3]]],[11,"into_token_stream","","Convert self directly into a TokenStream object.",2,[[],["tokenstream",3]]],[14,"format_ident","","Formatting macro for constructing Idents.",null,null],[14,"quote","","The whole point.",null,null],[14,"quote_spanned","","Same as quote!, but applies a given span to all tokens …",null,null],[11,"span","","Span associated with this IdentFragment.",1,[[],[["option",4],["span",3]]]],[11,"to_token_stream","","Convert self directly into a TokenStream object.",2,[[],["tokenstream",3]]],[11,"into_token_stream","","Convert self directly into a TokenStream object.",2,[[],["tokenstream",3]]]],"p":[[8,"TokenStreamExt"],[8,"IdentFragment"],[8,"ToTokens"]]},\ -"syn":{"doc":"github crates-io docs-rs","i":[[3,"Ident","syn","A word of Rust code, which may be a keyword or legal …",null,null],[0,"token","","Tokens representing Rust punctuation, keywords, and …",null,null],[8,"Token","syn::token","Marker trait for types that represent single tokens.",null,null],[3,"Underscore","","_",null,null],[12,"spans","","",0,null],[3,"Abstract","","abstract",null,null],[12,"span","","",1,null],[3,"As","","as",null,null],[12,"span","","",2,null],[3,"Async","","async",null,null],[12,"span","","",3,null],[3,"Auto","","auto",null,null],[12,"span","","",4,null],[3,"Await","","await",null,null],[12,"span","","",5,null],[3,"Become","","become",null,null],[12,"span","","",6,null],[3,"Box","","box",null,null],[12,"span","","",7,null],[3,"Break","","break",null,null],[12,"span","","",8,null],[3,"Const","","const",null,null],[12,"span","","",9,null],[3,"Continue","","continue",null,null],[12,"span","","",10,null],[3,"Crate","","crate",null,null],[12,"span","","",11,null],[3,"Default","","default",null,null],[12,"span","","",12,null],[3,"Do","","do",null,null],[12,"span","","",13,null],[3,"Dyn","","dyn",null,null],[12,"span","","",14,null],[3,"Else","","else",null,null],[12,"span","","",15,null],[3,"Enum","","enum",null,null],[12,"span","","",16,null],[3,"Extern","","extern",null,null],[12,"span","","",17,null],[3,"Final","","final",null,null],[12,"span","","",18,null],[3,"Fn","","fn",null,null],[12,"span","","",19,null],[3,"For","","for",null,null],[12,"span","","",20,null],[3,"If","","if",null,null],[12,"span","","",21,null],[3,"Impl","","impl",null,null],[12,"span","","",22,null],[3,"In","","in",null,null],[12,"span","","",23,null],[3,"Let","","let",null,null],[12,"span","","",24,null],[3,"Loop","","loop",null,null],[12,"span","","",25,null],[3,"Macro","","macro",null,null],[12,"span","","",26,null],[3,"Match","","match",null,null],[12,"span","","",27,null],[3,"Mod","","mod",null,null],[12,"span","","",28,null],[3,"Move","","move",null,null],[12,"span","","",29,null],[3,"Mut","","mut",null,null],[12,"span","","",30,null],[3,"Override","","override",null,null],[12,"span","","",31,null],[3,"Priv","","priv",null,null],[12,"span","","",32,null],[3,"Pub","","pub",null,null],[12,"span","","",33,null],[3,"Ref","","ref",null,null],[12,"span","","",34,null],[3,"Return","","return",null,null],[12,"span","","",35,null],[3,"SelfType","","Self",null,null],[12,"span","","",36,null],[3,"SelfValue","","self",null,null],[12,"span","","",37,null],[3,"Static","","static",null,null],[12,"span","","",38,null],[3,"Struct","","struct",null,null],[12,"span","","",39,null],[3,"Super","","super",null,null],[12,"span","","",40,null],[3,"Trait","","trait",null,null],[12,"span","","",41,null],[3,"Try","","try",null,null],[12,"span","","",42,null],[3,"Type","","type",null,null],[12,"span","","",43,null],[3,"Typeof","","typeof",null,null],[12,"span","","",44,null],[3,"Union","","union",null,null],[12,"span","","",45,null],[3,"Unsafe","","unsafe",null,null],[12,"span","","",46,null],[3,"Unsized","","unsized",null,null],[12,"span","","",47,null],[3,"Use","","use",null,null],[12,"span","","",48,null],[3,"Virtual","","virtual",null,null],[12,"span","","",49,null],[3,"Where","","where",null,null],[12,"span","","",50,null],[3,"While","","while",null,null],[12,"span","","",51,null],[3,"Yield","","yield",null,null],[12,"span","","",52,null],[3,"Add","","+",null,null],[12,"spans","","",53,null],[3,"AddEq","","+=",null,null],[12,"spans","","",54,null],[3,"And","","&",null,null],[12,"spans","","",55,null],[3,"AndAnd","","&&",null,null],[12,"spans","","",56,null],[3,"AndEq","","&=",null,null],[12,"spans","","",57,null],[3,"At","","@",null,null],[12,"spans","","",58,null],[3,"Bang","","!",null,null],[12,"spans","","",59,null],[3,"Caret","","^",null,null],[12,"spans","","",60,null],[3,"CaretEq","","^=",null,null],[12,"spans","","",61,null],[3,"Colon","",":",null,null],[12,"spans","","",62,null],[3,"Colon2","","::",null,null],[12,"spans","","",63,null],[3,"Comma","",",",null,null],[12,"spans","","",64,null],[3,"Div","","/",null,null],[12,"spans","","",65,null],[3,"DivEq","","/=",null,null],[12,"spans","","",66,null],[3,"Dollar","","$",null,null],[12,"spans","","",67,null],[3,"Dot","",".",null,null],[12,"spans","","",68,null],[3,"Dot2","","..",null,null],[12,"spans","","",69,null],[3,"Dot3","","...",null,null],[12,"spans","","",70,null],[3,"DotDotEq","","..=",null,null],[12,"spans","","",71,null],[3,"Eq","","=",null,null],[12,"spans","","",72,null],[3,"EqEq","","==",null,null],[12,"spans","","",73,null],[3,"Ge","",">=",null,null],[12,"spans","","",74,null],[3,"Gt","",">",null,null],[12,"spans","","",75,null],[3,"Le","","<=",null,null],[12,"spans","","",76,null],[3,"Lt","","<",null,null],[12,"spans","","",77,null],[3,"MulEq","","*=",null,null],[12,"spans","","",78,null],[3,"Ne","","!=",null,null],[12,"spans","","",79,null],[3,"Or","","|",null,null],[12,"spans","","",80,null],[3,"OrEq","","|=",null,null],[12,"spans","","",81,null],[3,"OrOr","","||",null,null],[12,"spans","","",82,null],[3,"Pound","","#",null,null],[12,"spans","","",83,null],[3,"Question","","?",null,null],[12,"spans","","",84,null],[3,"RArrow","","->",null,null],[12,"spans","","",85,null],[3,"LArrow","","<-",null,null],[12,"spans","","",86,null],[3,"Rem","","%",null,null],[12,"spans","","",87,null],[3,"RemEq","","%=",null,null],[12,"spans","","",88,null],[3,"FatArrow","","=>",null,null],[12,"spans","","",89,null],[3,"Semi","",";",null,null],[12,"spans","","",90,null],[3,"Shl","","<<",null,null],[12,"spans","","",91,null],[3,"ShlEq","","<<=",null,null],[12,"spans","","",92,null],[3,"Shr","",">>",null,null],[12,"spans","","",93,null],[3,"ShrEq","",">>=",null,null],[12,"spans","","",94,null],[3,"Star","","*",null,null],[12,"spans","","",95,null],[3,"Sub","","-",null,null],[12,"spans","","",96,null],[3,"SubEq","","-=",null,null],[12,"spans","","",97,null],[3,"Tilde","","~",null,null],[12,"spans","","",98,null],[3,"Brace","","{...}",null,null],[12,"span","","",99,null],[11,"surround","","",99,[[["tokenstream",3]]]],[3,"Bracket","","[...]",null,null],[12,"span","","",100,null],[11,"surround","","",100,[[["tokenstream",3]]]],[3,"Paren","","(...)",null,null],[12,"span","","",101,null],[11,"surround","","",101,[[["tokenstream",3]]]],[3,"Group","","None-delimited group",null,null],[12,"span","","",102,null],[11,"surround","","",102,[[["tokenstream",3]]]],[0,"buffer","syn","A stably addressed token buffer supporting efficient …",null,null],[3,"TokenBuffer","syn::buffer","A buffer that can be efficiently traversed multiple …",null,null],[11,"new","","Creates a TokenBuffer containing all the tokens from the …",103,[[["tokenstream",3]],["tokenbuffer",3]]],[11,"new2","","Creates a TokenBuffer containing all the tokens from the …",103,[[["tokenstream",3]],["tokenbuffer",3]]],[11,"begin","","Creates a cursor referencing the first token in the …",103,[[],["cursor",3]]],[3,"Cursor","","A cheaply copyable cursor into a TokenBuffer.",null,null],[11,"empty","","Creates a cursor referencing a static empty TokenStream.",104,[[]]],[11,"eof","","Checks whether the cursor is currently pointing at the …",104,[[]]],[11,"group","","If the cursor is pointing at a Group with the given …",104,[[["delimiter",4]],["option",4]]],[11,"ident","","If the cursor is pointing at a Ident, returns it along …",104,[[],["option",4]]],[11,"punct","","If the cursor is pointing at an Punct, returns it along …",104,[[],["option",4]]],[11,"literal","","If the cursor is pointing at a Literal, return it along …",104,[[],["option",4]]],[11,"lifetime","","If the cursor is pointing at a Lifetime, returns it along …",104,[[],["option",4]]],[11,"token_stream","","Copies all remaining tokens visible from this cursor into …",104,[[],["tokenstream",3]]],[11,"token_tree","","If the cursor is pointing at a TokenTree, returns it …",104,[[],["option",4]]],[11,"span","","Returns the Span of the current token, or …",104,[[],["span",3]]],[0,"ext","syn","Extension traits to provide parsing methods on foreign …",null,null],[8,"IdentExt","syn::ext","Additional methods for Ident not provided by proc-macro2 …",null,null],[10,"parse_any","","Parses any identifier including keywords.",105,[[["parsestream",6]],["result",6]]],[18,"peek_any","","Peeks any identifier including keywords. Usage: …",105,null],[10,"unraw","","Strips the raw marker r#, if any, from the beginning of …",105,[[],["ident",3]]],[0,"punctuated","syn","A punctuated sequence of syntax tree nodes separated by …",null,null],[3,"Punctuated","syn::punctuated","A punctuated sequence of syntax tree nodes of type T …",null,null],[11,"new","","Creates an empty punctuated sequence.",106,[[]]],[11,"is_empty","","Determines whether this punctuated sequence is empty, …",106,[[]]],[11,"len","","Returns the number of syntax tree nodes in this …",106,[[]]],[11,"first","","Borrows the first element in this sequence.",106,[[],["option",4]]],[11,"first_mut","","Mutably borrows the first element in this sequence.",106,[[],["option",4]]],[11,"last","","Borrows the last element in this sequence.",106,[[],["option",4]]],[11,"last_mut","","Mutably borrows the last element in this sequence.",106,[[],["option",4]]],[11,"iter","","Returns an iterator over borrowed syntax tree nodes of …",106,[[],["iter",3]]],[11,"iter_mut","","Returns an iterator over mutably borrowed syntax tree …",106,[[],["itermut",3]]],[11,"pairs","","Returns an iterator over the contents of this sequence as …",106,[[],["pairs",3]]],[11,"pairs_mut","","Returns an iterator over the contents of this sequence as …",106,[[],["pairsmut",3]]],[11,"into_pairs","","Returns an iterator over the contents of this sequence as …",106,[[],["intopairs",3]]],[11,"push_value","","Appends a syntax tree node onto the end of this …",106,[[]]],[11,"push_punct","","Appends a trailing punctuation onto the end of this …",106,[[]]],[11,"pop","","Removes the last punctuated pair from this sequence, or …",106,[[],[["option",4],["pair",4]]]],[11,"trailing_punct","","Determines whether this punctuated sequence ends with a …",106,[[]]],[11,"empty_or_trailing","","Returns true if either this Punctuated is empty, or it …",106,[[]]],[11,"push","","Appends a syntax tree node onto the end of this …",106,[[]]],[11,"insert","","Inserts an element at position index.",106,[[]]],[11,"clear","","Clears the sequence of all values and punctuation, making …",106,[[]]],[11,"parse_terminated","","Parses zero or more occurrences of T separated by …",106,[[["parsestream",6]],["result",6]]],[11,"parse_terminated_with","","Parses zero or more occurrences of T using the given …",106,[[["parsestream",6]],["result",6]]],[11,"parse_separated_nonempty","","Parses one or more occurrences of T separated by …",106,[[["parsestream",6]],["result",6]]],[11,"parse_separated_nonempty_with","","Parses one or more occurrences of T using the given parse …",106,[[["parsestream",6]],["result",6]]],[3,"Pairs","","An iterator over borrowed pairs of type Pair<&T, &P>.",null,null],[3,"PairsMut","","An iterator over mutably borrowed pairs of type …",null,null],[3,"IntoPairs","","An iterator over owned pairs of type Pair.",null,null],[3,"IntoIter","","An iterator over owned values of type T.",null,null],[3,"Iter","","An iterator over borrowed values of type &T.",null,null],[3,"IterMut","","An iterator over mutably borrowed values of type &mut T.",null,null],[4,"Pair","","A single syntax tree node of type T followed by its …",null,null],[13,"Punctuated","","",107,null],[13,"End","","",107,null],[11,"into_value","","Extracts the syntax tree node from this punctuated pair, …",107,[[]]],[11,"value","","Borrows the syntax tree node from this punctuated pair.",107,[[]]],[11,"value_mut","","Mutably borrows the syntax tree node from this punctuated …",107,[[]]],[11,"punct","","Borrows the punctuation from this punctuated pair, unless …",107,[[],["option",4]]],[11,"new","","Creates a punctuated pair out of a syntax tree node and …",107,[[["option",4]]]],[11,"into_tuple","","Produces this punctuated pair as a tuple of syntax tree …",107,[[]]],[0,"spanned","syn","A trait that can provide the Span of the complete …",null,null],[8,"Spanned","syn::spanned","A trait that can provide the Span of the complete …",null,null],[10,"span","","Returns a Span covering the complete contents of this …",108,[[],["span",3]]],[0,"visit","syn","Syntax tree traversal to walk a shared borrow of a syntax …",null,null],[8,"Visit","syn::visit","Syntax tree traversal to walk a shared borrow of a syntax …",null,null],[11,"visit_abi","","",109,[[["abi",3]]]],[11,"visit_angle_bracketed_generic_arguments","","",109,[[["anglebracketedgenericarguments",3]]]],[11,"visit_attr_style","","",109,[[["attrstyle",4]]]],[11,"visit_attribute","","",109,[[["attribute",3]]]],[11,"visit_bare_fn_arg","","",109,[[["barefnarg",3]]]],[11,"visit_bin_op","","",109,[[["binop",4]]]],[11,"visit_binding","","",109,[[["binding",3]]]],[11,"visit_bound_lifetimes","","",109,[[["boundlifetimes",3]]]],[11,"visit_const_param","","",109,[[["constparam",3]]]],[11,"visit_constraint","","",109,[[["constraint",3]]]],[11,"visit_data","","",109,[[["data",4]]]],[11,"visit_data_enum","","",109,[[["dataenum",3]]]],[11,"visit_data_struct","","",109,[[["datastruct",3]]]],[11,"visit_data_union","","",109,[[["dataunion",3]]]],[11,"visit_derive_input","","",109,[[["deriveinput",3]]]],[11,"visit_expr","","",109,[[["expr",4]]]],[11,"visit_expr_binary","","",109,[[["exprbinary",3]]]],[11,"visit_expr_call","","",109,[[["exprcall",3]]]],[11,"visit_expr_cast","","",109,[[["exprcast",3]]]],[11,"visit_expr_field","","",109,[[["exprfield",3]]]],[11,"visit_expr_index","","",109,[[["exprindex",3]]]],[11,"visit_expr_lit","","",109,[[["exprlit",3]]]],[11,"visit_expr_paren","","",109,[[["exprparen",3]]]],[11,"visit_expr_path","","",109,[[["exprpath",3]]]],[11,"visit_expr_unary","","",109,[[["exprunary",3]]]],[11,"visit_field","","",109,[[["field",3]]]],[11,"visit_fields","","",109,[[["fields",4]]]],[11,"visit_fields_named","","",109,[[["fieldsnamed",3]]]],[11,"visit_fields_unnamed","","",109,[[["fieldsunnamed",3]]]],[11,"visit_generic_argument","","",109,[[["genericargument",4]]]],[11,"visit_generic_param","","",109,[[["genericparam",4]]]],[11,"visit_generics","","",109,[[["generics",3]]]],[11,"visit_ident","","",109,[[["ident",3]]]],[11,"visit_index","","",109,[[["index",3]]]],[11,"visit_lifetime","","",109,[[["lifetime",3]]]],[11,"visit_lifetime_def","","",109,[[["lifetimedef",3]]]],[11,"visit_lit","","",109,[[["lit",4]]]],[11,"visit_lit_bool","","",109,[[["litbool",3]]]],[11,"visit_lit_byte","","",109,[[["litbyte",3]]]],[11,"visit_lit_byte_str","","",109,[[["litbytestr",3]]]],[11,"visit_lit_char","","",109,[[["litchar",3]]]],[11,"visit_lit_float","","",109,[[["litfloat",3]]]],[11,"visit_lit_int","","",109,[[["litint",3]]]],[11,"visit_lit_str","","",109,[[["litstr",3]]]],[11,"visit_macro","","",109,[[["macro",3]]]],[11,"visit_macro_delimiter","","",109,[[["macrodelimiter",4]]]],[11,"visit_member","","",109,[[["member",4]]]],[11,"visit_meta","","",109,[[["meta",4]]]],[11,"visit_meta_list","","",109,[[["metalist",3]]]],[11,"visit_meta_name_value","","",109,[[["metanamevalue",3]]]],[11,"visit_nested_meta","","",109,[[["nestedmeta",4]]]],[11,"visit_parenthesized_generic_arguments","","",109,[[["parenthesizedgenericarguments",3]]]],[11,"visit_path","","",109,[[["path",3]]]],[11,"visit_path_arguments","","",109,[[["patharguments",4]]]],[11,"visit_path_segment","","",109,[[["pathsegment",3]]]],[11,"visit_predicate_eq","","",109,[[["predicateeq",3]]]],[11,"visit_predicate_lifetime","","",109,[[["predicatelifetime",3]]]],[11,"visit_predicate_type","","",109,[[["predicatetype",3]]]],[11,"visit_qself","","",109,[[["qself",3]]]],[11,"visit_return_type","","",109,[[["returntype",4]]]],[11,"visit_span","","",109,[[["span",3]]]],[11,"visit_trait_bound","","",109,[[["traitbound",3]]]],[11,"visit_trait_bound_modifier","","",109,[[["traitboundmodifier",4]]]],[11,"visit_type","","",109,[[["type",4]]]],[11,"visit_type_array","","",109,[[["typearray",3]]]],[11,"visit_type_bare_fn","","",109,[[["typebarefn",3]]]],[11,"visit_type_group","","",109,[[["typegroup",3]]]],[11,"visit_type_impl_trait","","",109,[[["typeimpltrait",3]]]],[11,"visit_type_infer","","",109,[[["typeinfer",3]]]],[11,"visit_type_macro","","",109,[[["typemacro",3]]]],[11,"visit_type_never","","",109,[[["typenever",3]]]],[11,"visit_type_param","","",109,[[["typeparam",3]]]],[11,"visit_type_param_bound","","",109,[[["typeparambound",4]]]],[11,"visit_type_paren","","",109,[[["typeparen",3]]]],[11,"visit_type_path","","",109,[[["typepath",3]]]],[11,"visit_type_ptr","","",109,[[["typeptr",3]]]],[11,"visit_type_reference","","",109,[[["typereference",3]]]],[11,"visit_type_slice","","",109,[[["typeslice",3]]]],[11,"visit_type_trait_object","","",109,[[["typetraitobject",3]]]],[11,"visit_type_tuple","","",109,[[["typetuple",3]]]],[11,"visit_un_op","","",109,[[["unop",4]]]],[11,"visit_variadic","","",109,[[["variadic",3]]]],[11,"visit_variant","","",109,[[["variant",3]]]],[11,"visit_vis_crate","","",109,[[["viscrate",3]]]],[11,"visit_vis_public","","",109,[[["vispublic",3]]]],[11,"visit_vis_restricted","","",109,[[["visrestricted",3]]]],[11,"visit_visibility","","",109,[[["visibility",4]]]],[11,"visit_where_clause","","",109,[[["whereclause",3]]]],[11,"visit_where_predicate","","",109,[[["wherepredicate",4]]]],[5,"visit_abi","","",null,[[["abi",3]]]],[5,"visit_angle_bracketed_generic_arguments","","",null,[[["anglebracketedgenericarguments",3]]]],[5,"visit_attr_style","","",null,[[["attrstyle",4]]]],[5,"visit_attribute","","",null,[[["attribute",3]]]],[5,"visit_bare_fn_arg","","",null,[[["barefnarg",3]]]],[5,"visit_bin_op","","",null,[[["binop",4]]]],[5,"visit_binding","","",null,[[["binding",3]]]],[5,"visit_bound_lifetimes","","",null,[[["boundlifetimes",3]]]],[5,"visit_const_param","","",null,[[["constparam",3]]]],[5,"visit_constraint","","",null,[[["constraint",3]]]],[5,"visit_data","","",null,[[["data",4]]]],[5,"visit_data_enum","","",null,[[["dataenum",3]]]],[5,"visit_data_struct","","",null,[[["datastruct",3]]]],[5,"visit_data_union","","",null,[[["dataunion",3]]]],[5,"visit_derive_input","","",null,[[["deriveinput",3]]]],[5,"visit_expr","","",null,[[["expr",4]]]],[5,"visit_expr_binary","","",null,[[["exprbinary",3]]]],[5,"visit_expr_call","","",null,[[["exprcall",3]]]],[5,"visit_expr_cast","","",null,[[["exprcast",3]]]],[5,"visit_expr_field","","",null,[[["exprfield",3]]]],[5,"visit_expr_index","","",null,[[["exprindex",3]]]],[5,"visit_expr_lit","","",null,[[["exprlit",3]]]],[5,"visit_expr_paren","","",null,[[["exprparen",3]]]],[5,"visit_expr_path","","",null,[[["exprpath",3]]]],[5,"visit_expr_unary","","",null,[[["exprunary",3]]]],[5,"visit_field","","",null,[[["field",3]]]],[5,"visit_fields","","",null,[[["fields",4]]]],[5,"visit_fields_named","","",null,[[["fieldsnamed",3]]]],[5,"visit_fields_unnamed","","",null,[[["fieldsunnamed",3]]]],[5,"visit_generic_argument","","",null,[[["genericargument",4]]]],[5,"visit_generic_param","","",null,[[["genericparam",4]]]],[5,"visit_generics","","",null,[[["generics",3]]]],[5,"visit_ident","","",null,[[["ident",3]]]],[5,"visit_index","","",null,[[["index",3]]]],[5,"visit_lifetime","","",null,[[["lifetime",3]]]],[5,"visit_lifetime_def","","",null,[[["lifetimedef",3]]]],[5,"visit_lit","","",null,[[["lit",4]]]],[5,"visit_lit_bool","","",null,[[["litbool",3]]]],[5,"visit_lit_byte","","",null,[[["litbyte",3]]]],[5,"visit_lit_byte_str","","",null,[[["litbytestr",3]]]],[5,"visit_lit_char","","",null,[[["litchar",3]]]],[5,"visit_lit_float","","",null,[[["litfloat",3]]]],[5,"visit_lit_int","","",null,[[["litint",3]]]],[5,"visit_lit_str","","",null,[[["litstr",3]]]],[5,"visit_macro","","",null,[[["macro",3]]]],[5,"visit_macro_delimiter","","",null,[[["macrodelimiter",4]]]],[5,"visit_member","","",null,[[["member",4]]]],[5,"visit_meta","","",null,[[["meta",4]]]],[5,"visit_meta_list","","",null,[[["metalist",3]]]],[5,"visit_meta_name_value","","",null,[[["metanamevalue",3]]]],[5,"visit_nested_meta","","",null,[[["nestedmeta",4]]]],[5,"visit_parenthesized_generic_arguments","","",null,[[["parenthesizedgenericarguments",3]]]],[5,"visit_path","","",null,[[["path",3]]]],[5,"visit_path_arguments","","",null,[[["patharguments",4]]]],[5,"visit_path_segment","","",null,[[["pathsegment",3]]]],[5,"visit_predicate_eq","","",null,[[["predicateeq",3]]]],[5,"visit_predicate_lifetime","","",null,[[["predicatelifetime",3]]]],[5,"visit_predicate_type","","",null,[[["predicatetype",3]]]],[5,"visit_qself","","",null,[[["qself",3]]]],[5,"visit_return_type","","",null,[[["returntype",4]]]],[5,"visit_span","","",null,[[["span",3]]]],[5,"visit_trait_bound","","",null,[[["traitbound",3]]]],[5,"visit_trait_bound_modifier","","",null,[[["traitboundmodifier",4]]]],[5,"visit_type","","",null,[[["type",4]]]],[5,"visit_type_array","","",null,[[["typearray",3]]]],[5,"visit_type_bare_fn","","",null,[[["typebarefn",3]]]],[5,"visit_type_group","","",null,[[["typegroup",3]]]],[5,"visit_type_impl_trait","","",null,[[["typeimpltrait",3]]]],[5,"visit_type_infer","","",null,[[["typeinfer",3]]]],[5,"visit_type_macro","","",null,[[["typemacro",3]]]],[5,"visit_type_never","","",null,[[["typenever",3]]]],[5,"visit_type_param","","",null,[[["typeparam",3]]]],[5,"visit_type_param_bound","","",null,[[["typeparambound",4]]]],[5,"visit_type_paren","","",null,[[["typeparen",3]]]],[5,"visit_type_path","","",null,[[["typepath",3]]]],[5,"visit_type_ptr","","",null,[[["typeptr",3]]]],[5,"visit_type_reference","","",null,[[["typereference",3]]]],[5,"visit_type_slice","","",null,[[["typeslice",3]]]],[5,"visit_type_trait_object","","",null,[[["typetraitobject",3]]]],[5,"visit_type_tuple","","",null,[[["typetuple",3]]]],[5,"visit_un_op","","",null,[[["unop",4]]]],[5,"visit_variadic","","",null,[[["variadic",3]]]],[5,"visit_variant","","",null,[[["variant",3]]]],[5,"visit_vis_crate","","",null,[[["viscrate",3]]]],[5,"visit_vis_public","","",null,[[["vispublic",3]]]],[5,"visit_vis_restricted","","",null,[[["visrestricted",3]]]],[5,"visit_visibility","","",null,[[["visibility",4]]]],[5,"visit_where_clause","","",null,[[["whereclause",3]]]],[5,"visit_where_predicate","","",null,[[["wherepredicate",4]]]],[0,"parse","syn","Parsing interface for parsing a token stream into a …",null,null],[0,"discouraged","syn::parse","Extensions to the parsing API with niche applicability.",null,null],[8,"Speculative","syn::parse::discouraged","Extensions to the ParseStream API to support speculative …",null,null],[10,"advance_to","","Advance this parse stream to the position of a forked …",110,[[]]],[3,"Error","syn::parse","Error returned when a Syn parser cannot parse the input …",null,null],[6,"Result","","The result of a Syn parser.",null,null],[3,"Lookahead1","","Support for checking the next token in a stream to decide …",null,null],[8,"Peek","","Types that can be parsed by looking at just one token.",null,null],[8,"Parse","","Parsing interface implemented by all types that can be …",null,null],[10,"parse","","",111,[[["parsestream",6]],["result",6]]],[6,"ParseStream","","Input to a Syn parser function.",null,null],[3,"ParseBuffer","","Cursor position within a buffered token stream.",null,null],[3,"StepCursor","","Cursor state associated with speculative parsing.",null,null],[11,"error","","Triggers an error at the current position of the parse …",112,[[["display",8]],["error",3]]],[11,"parse","","Parses a syntax tree node of type T, advancing the …",113,[[],[["result",6],["parse",8]]]],[11,"call","","Calls the given parser function to parse a syntax tree …",113,[[],["result",6]]],[11,"peek","","Looks at the next token in the parse stream to determine …",113,[[["peek",8]]]],[11,"peek2","","Looks at the second-next token in the parse stream.",113,[[["peek",8]]]],[11,"peek3","","Looks at the third-next token in the parse stream.",113,[[["peek",8]]]],[11,"parse_terminated","","Parses zero or more occurrences of T separated by …",113,[[],[["result",6],["punctuated",3]]]],[11,"is_empty","","Returns whether there are tokens remaining in this stream.",113,[[]]],[11,"lookahead1","","Constructs a helper for peeking at the next token in this …",113,[[],["lookahead1",3]]],[11,"fork","","Forks a parse stream so that parsing tokens out of either …",113,[[]]],[11,"error","","Triggers an error at the current position of the parse …",113,[[["display",8]],["error",3]]],[11,"step","","Speculatively parses tokens from this parse stream, …",113,[[],["result",6]]],[11,"span","","Returns the Span of the next token in the parse stream, or…",113,[[],["span",3]]],[11,"cursor","","Provides low-level access to the token representation …",113,[[],["cursor",3]]],[8,"Parser","","Parser that can parse Rust tokens into a particular …",null,null],[16,"Output","","",114,null],[10,"parse2","","Parse a proc-macro2 token stream into the chosen syntax …",114,[[["tokenstream",3]],["result",6]]],[11,"parse","","Parse tokens of source code into the chosen syntax tree …",114,[[["tokenstream",3]],["result",6]]],[11,"parse_str","","Parse a string of Rust code into the chosen syntax tree …",114,[[],["result",6]]],[3,"Nothing","","An empty syntax tree node that consumes no tokens when …",null,null],[11,"new","","Usually the ParseStream::error method will be used …",115,[[["span",3],["display",8]]]],[11,"new_spanned","","Creates an error with the specified message spanning the …",115,[[["totokens",8],["display",8]]]],[11,"span","","The source location of the error.",115,[[],["span",3]]],[11,"to_compile_error","","Render the error as an invocation of compile_error!.",115,[[],["tokenstream",3]]],[11,"into_compile_error","","Render the error as an invocation of compile_error!.",115,[[],["tokenstream",3]]],[11,"combine","","Add another error message to self such that when …",115,[[["error",3]]]],[4,"AttrStyle","syn","Distinguishes between attributes that decorate an item …",null,null],[13,"Outer","","",116,null],[13,"Inner","","",116,null],[3,"Attribute","","An attribute like #[repr(transparent)].",null,null],[12,"pound_token","","",117,null],[12,"style","","",117,null],[12,"bracket_token","","",117,null],[12,"path","","",117,null],[12,"tokens","","",117,null],[6,"AttributeArgs","","Conventional argument type associated with an invocation …",null,null],[4,"Meta","","Content of a compile-time structured attribute.",null,null],[13,"Path","","",118,null],[13,"List","","A structured list within an attribute, like …",118,null],[13,"NameValue","","A name-value pair within an attribute, like …",118,null],[3,"MetaList","","A structured list within an attribute, like …",null,null],[12,"path","","",119,null],[12,"paren_token","","",119,null],[12,"nested","","",119,null],[3,"MetaNameValue","","A name-value pair within an attribute, like …",null,null],[12,"path","","",120,null],[12,"eq_token","","",120,null],[12,"lit","","",120,null],[4,"NestedMeta","","Element of a compile-time attribute list.",null,null],[13,"Meta","","A structured meta item, like the Copy in #[derive(Copy)] …",121,null],[13,"Lit","","A Rust literal, like the \\\"new_name\\\" in …",121,null],[3,"Field","","A field of a struct or enum variant.",null,null],[12,"attrs","","Attributes tagged on the field.",122,null],[12,"vis","","Visibility of the field.",122,null],[12,"ident","","Name of the field, if any.",122,null],[12,"colon_token","","",122,null],[12,"ty","","Type of the field.",122,null],[4,"Fields","","Data stored within an enum variant or struct.",null,null],[13,"Named","","Named fields of a struct or struct variant such as …",123,null],[13,"Unnamed","","Unnamed fields of a tuple struct or tuple variant such as …",123,null],[13,"Unit","","Unit struct or unit variant such as None.",123,null],[3,"FieldsNamed","","Named fields of a struct or struct variant such as …",null,null],[12,"brace_token","","",124,null],[12,"named","","",124,null],[3,"FieldsUnnamed","","Unnamed fields of a tuple struct or tuple variant such as …",null,null],[12,"paren_token","","",125,null],[12,"unnamed","","",125,null],[3,"Variant","","An enum variant.",null,null],[12,"attrs","","Attributes tagged on the variant.",126,null],[12,"ident","","Name of the variant.",126,null],[12,"fields","","Content stored in the variant.",126,null],[12,"discriminant","","Explicit discriminant: Variant = 1",126,null],[3,"VisCrate","","A crate-level visibility: crate.",null,null],[12,"crate_token","","",127,null],[3,"VisPublic","","A public visibility level: pub.",null,null],[12,"pub_token","","",128,null],[3,"VisRestricted","","A visibility level restricted to some path: pub(self) or …",null,null],[12,"pub_token","","",129,null],[12,"paren_token","","",129,null],[12,"in_token","","",129,null],[12,"path","","",129,null],[4,"Visibility","","The visibility level of an item: inherited or pub or …",null,null],[13,"Public","","A public visibility level: pub.",130,null],[13,"Crate","","A crate-level visibility: crate.",130,null],[13,"Restricted","","A visibility level restricted to some path: pub(self) or …",130,null],[13,"Inherited","","An inherited visibility, which usually means private.",130,null],[4,"Expr","","A Rust expression.",null,null],[13,"Array","","A slice literal expression: [a, b, c, d].",131,null],[13,"Assign","","An assignment expression: a = compute().",131,null],[13,"AssignOp","","A compound assignment expression: counter += 1.",131,null],[13,"Async","","An async block: async { ... }.",131,null],[13,"Await","","An await expression: fut.await.",131,null],[13,"Binary","","A binary operation: a + b, a * b.",131,null],[13,"Block","","A blocked scope: { ... }.",131,null],[13,"Box","","A box expression: box f.",131,null],[13,"Break","","A break, with an optional label to break and an optional …",131,null],[13,"Call","","A function call expression: invoke(a, b).",131,null],[13,"Cast","","A cast expression: foo as f64.",131,null],[13,"Closure","","A closure expression: |a, b| a + b.",131,null],[13,"Continue","","A continue, with an optional label.",131,null],[13,"Field","","Access of a named struct field (obj.k) or unnamed tuple …",131,null],[13,"ForLoop","","A for loop: for pat in expr { ... }.",131,null],[13,"Group","","An expression contained within invisible delimiters.",131,null],[13,"If","","An if expression with an optional else block: …",131,null],[13,"Index","","A square bracketed indexing expression: vector[2].",131,null],[13,"Let","","A let guard: let Some(x) = opt.",131,null],[13,"Lit","","A literal in place of an expression: 1, \\\"foo\\\".",131,null],[13,"Loop","","Conditionless loop: loop { ... }.",131,null],[13,"Macro","","A macro invocation expression: format!(\\\"{}\\\", q).",131,null],[13,"Match","","A match expression: match n { Some(n) => {}, None => {} }.",131,null],[13,"MethodCall","","A method call expression: x.foo::(a, b).",131,null],[13,"Paren","","A parenthesized expression: (a + b).",131,null],[13,"Path","","A path like std::mem::replace possibly containing generic …",131,null],[13,"Range","","A range expression: 1..2, 1.., ..2, 1..=2, ..=2.",131,null],[13,"Reference","","A referencing operation: &a or &mut a.",131,null],[13,"Repeat","","An array literal constructed from one repeated element: …",131,null],[13,"Return","","A return, with an optional value to be returned.",131,null],[13,"Struct","","A struct literal expression: Point { x: 1, y: 1 }.",131,null],[13,"Try","","A try-expression: expr?.",131,null],[13,"TryBlock","","A try block: try { ... }.",131,null],[13,"Tuple","","A tuple expression: (a, b, c, d).",131,null],[13,"Type","","A type ascription expression: foo: f64.",131,null],[13,"Unary","","A unary operation: !x, *x.",131,null],[13,"Unsafe","","An unsafe block: unsafe { ... }.",131,null],[13,"Verbatim","","Tokens in expression position not interpreted by Syn.",131,null],[13,"While","","A while loop: while expr { ... }.",131,null],[13,"Yield","","A yield expression: yield expr.",131,null],[3,"ExprArray","","A slice literal expression: [a, b, c, d].",null,null],[3,"ExprAssign","","An assignment expression: a = compute().",null,null],[3,"ExprAssignOp","","A compound assignment expression: counter += 1.",null,null],[3,"ExprAsync","","An async block: async { ... }.",null,null],[3,"ExprAwait","","An await expression: fut.await.",null,null],[3,"ExprBinary","","A binary operation: a + b, a * b.",null,null],[12,"attrs","","",132,null],[12,"left","","",132,null],[12,"op","","",132,null],[12,"right","","",132,null],[3,"ExprBlock","","A blocked scope: { ... }.",null,null],[3,"ExprBox","","A box expression: box f.",null,null],[3,"ExprBreak","","A break, with an optional label to break and an optional …",null,null],[3,"ExprCall","","A function call expression: invoke(a, b).",null,null],[12,"attrs","","",133,null],[12,"func","","",133,null],[12,"paren_token","","",133,null],[12,"args","","",133,null],[3,"ExprCast","","A cast expression: foo as f64.",null,null],[12,"attrs","","",134,null],[12,"expr","","",134,null],[12,"as_token","","",134,null],[12,"ty","","",134,null],[3,"ExprClosure","","A closure expression: |a, b| a + b.",null,null],[3,"ExprContinue","","A continue, with an optional label.",null,null],[3,"ExprField","","Access of a named struct field (obj.k) or unnamed tuple …",null,null],[12,"attrs","","",135,null],[12,"base","","",135,null],[12,"dot_token","","",135,null],[12,"member","","",135,null],[3,"ExprForLoop","","A for loop: for pat in expr { ... }.",null,null],[3,"ExprGroup","","An expression contained within invisible delimiters.",null,null],[3,"ExprIf","","An if expression with an optional else block: …",null,null],[3,"ExprIndex","","A square bracketed indexing expression: vector[2].",null,null],[12,"attrs","","",136,null],[12,"expr","","",136,null],[12,"bracket_token","","",136,null],[12,"index","","",136,null],[3,"ExprLet","","A let guard: let Some(x) = opt.",null,null],[3,"ExprLit","","A literal in place of an expression: 1, \\\"foo\\\".",null,null],[12,"attrs","","",137,null],[12,"lit","","",137,null],[3,"ExprLoop","","Conditionless loop: loop { ... }.",null,null],[3,"ExprMacro","","A macro invocation expression: format!(\\\"{}\\\", q).",null,null],[3,"ExprMatch","","A match expression: match n { Some(n) => {}, None => {} }.",null,null],[3,"ExprMethodCall","","A method call expression: x.foo::(a, b).",null,null],[3,"ExprParen","","A parenthesized expression: (a + b).",null,null],[12,"attrs","","",138,null],[12,"paren_token","","",138,null],[12,"expr","","",138,null],[3,"ExprPath","","A path like std::mem::replace possibly containing generic …",null,null],[12,"attrs","","",139,null],[12,"qself","","",139,null],[12,"path","","",139,null],[3,"ExprRange","","A range expression: 1..2, 1.., ..2, 1..=2, ..=2.",null,null],[3,"ExprReference","","A referencing operation: &a or &mut a.",null,null],[3,"ExprRepeat","","An array literal constructed from one repeated element: …",null,null],[3,"ExprReturn","","A return, with an optional value to be returned.",null,null],[3,"ExprStruct","","A struct literal expression: Point { x: 1, y: 1 }.",null,null],[3,"ExprTry","","A try-expression: expr?.",null,null],[3,"ExprTryBlock","","A try block: try { ... }.",null,null],[3,"ExprTuple","","A tuple expression: (a, b, c, d).",null,null],[3,"ExprType","","A type ascription expression: foo: f64.",null,null],[3,"ExprUnary","","A unary operation: !x, *x.",null,null],[12,"attrs","","",140,null],[12,"op","","",140,null],[12,"expr","","",140,null],[3,"ExprUnsafe","","An unsafe block: unsafe { ... }.",null,null],[3,"ExprWhile","","A while loop: while expr { ... }.",null,null],[3,"ExprYield","","A yield expression: yield expr.",null,null],[3,"Index","","The index of an unnamed tuple struct field.",null,null],[12,"index","","",141,null],[12,"span","","",141,null],[4,"Member","","A struct or tuple struct field accessed in a struct …",null,null],[13,"Named","","A named field like self.x.",142,null],[13,"Unnamed","","An unnamed field like self.0.",142,null],[3,"BoundLifetimes","","A set of bound lifetimes: for<\'a, \'b, \'c>.",null,null],[12,"for_token","","",143,null],[12,"lt_token","","",143,null],[12,"lifetimes","","",143,null],[12,"gt_token","","",143,null],[3,"ConstParam","","A const generic parameter: const LENGTH: usize.",null,null],[12,"attrs","","",144,null],[12,"const_token","","",144,null],[12,"ident","","",144,null],[12,"colon_token","","",144,null],[12,"ty","","",144,null],[12,"eq_token","","",144,null],[12,"default","","",144,null],[4,"GenericParam","","A generic type parameter, lifetime, or const generic: …",null,null],[13,"Type","","A generic type parameter: T: Into.",145,null],[13,"Lifetime","","A lifetime definition: \'a: \'b + \'c + \'d.",145,null],[13,"Const","","A const generic parameter: const LENGTH: usize.",145,null],[3,"Generics","","Lifetimes and type parameters attached to a declaration …",null,null],[12,"lt_token","","",146,null],[12,"params","","",146,null],[12,"gt_token","","",146,null],[12,"where_clause","","",146,null],[3,"LifetimeDef","","A lifetime definition: \'a: \'b + \'c + \'d.",null,null],[12,"attrs","","",147,null],[12,"lifetime","","",147,null],[12,"colon_token","","",147,null],[12,"bounds","","",147,null],[3,"PredicateEq","","An equality predicate in a where clause (unsupported).",null,null],[12,"lhs_ty","","",148,null],[12,"eq_token","","",148,null],[12,"rhs_ty","","",148,null],[3,"PredicateLifetime","","A lifetime predicate in a where clause: \'a: \'b + \'c.",null,null],[12,"lifetime","","",149,null],[12,"colon_token","","",149,null],[12,"bounds","","",149,null],[3,"PredicateType","","A type predicate in a where clause: …",null,null],[12,"lifetimes","","Any lifetimes from a for binding",150,null],[12,"bounded_ty","","The type being bounded",150,null],[12,"colon_token","","",150,null],[12,"bounds","","Trait and lifetime bounds (Clone+Send+\'static)",150,null],[3,"TraitBound","","A trait used as a bound on a type parameter.",null,null],[12,"paren_token","","",151,null],[12,"modifier","","",151,null],[12,"lifetimes","","The for<\'a> in for<\'a> Foo<&\'a T>",151,null],[12,"path","","The Foo<&\'a T> in for<\'a> Foo<&\'a T>",151,null],[4,"TraitBoundModifier","","A modifier on a trait bound, currently only used for the ?…",null,null],[13,"None","","",152,null],[13,"Maybe","","",152,null],[3,"TypeParam","","A generic type parameter: T: Into.",null,null],[12,"attrs","","",153,null],[12,"ident","","",153,null],[12,"colon_token","","",153,null],[12,"bounds","","",153,null],[12,"eq_token","","",153,null],[12,"default","","",153,null],[4,"TypeParamBound","","A trait or lifetime used as a bound on a type parameter.",null,null],[13,"Trait","","",154,null],[13,"Lifetime","","",154,null],[3,"WhereClause","","A where clause in a definition: …",null,null],[12,"where_token","","",155,null],[12,"predicates","","",155,null],[4,"WherePredicate","","A single predicate in a where clause: T: Deserialize<\'de>.",null,null],[13,"Type","","A type predicate in a where clause: …",156,null],[13,"Lifetime","","A lifetime predicate in a where clause: \'a: \'b + \'c.",156,null],[13,"Eq","","An equality predicate in a where clause (unsupported).",156,null],[3,"ImplGenerics","","Returned by Generics::split_for_impl.",null,null],[3,"Turbofish","","Returned by TypeGenerics::as_turbofish.",null,null],[3,"TypeGenerics","","Returned by Generics::split_for_impl.",null,null],[3,"Lifetime","","A Rust lifetime: \'a.",null,null],[12,"apostrophe","","",157,null],[12,"ident","","",157,null],[4,"Lit","","A Rust literal such as a string or integer or boolean.",null,null],[13,"Str","","A UTF-8 string literal: \\\"foo\\\".",158,null],[13,"ByteStr","","A byte string literal: b\\\"foo\\\".",158,null],[13,"Byte","","A byte literal: b\'f\'.",158,null],[13,"Char","","A character literal: \'a\'.",158,null],[13,"Int","","An integer literal: 1 or 1u16.",158,null],[13,"Float","","A floating point literal: 1f64 or 1.0e10f64.",158,null],[13,"Bool","","A boolean literal: true or false.",158,null],[13,"Verbatim","","A raw token literal not interpreted by Syn.",158,null],[3,"LitBool","","A boolean literal: true or false.",null,null],[12,"value","","",159,null],[12,"span","","",159,null],[3,"LitByte","","A byte literal: b\'f\'.",null,null],[3,"LitByteStr","","A byte string literal: b\\\"foo\\\".",null,null],[3,"LitChar","","A character literal: \'a\'.",null,null],[3,"LitFloat","","A floating point literal: 1f64 or 1.0e10f64.",null,null],[3,"LitInt","","An integer literal: 1 or 1u16.",null,null],[3,"LitStr","","A UTF-8 string literal: \\\"foo\\\".",null,null],[4,"StrStyle","","The style of a string literal, either plain quoted or a …",null,null],[13,"Cooked","","An ordinary string like \\\"data\\\".",160,null],[13,"Raw","","A raw string like r##\\\"data\\\"##.",160,null],[3,"Macro","","A macro invocation: println!(\\\"{}\\\", mac).",null,null],[12,"path","","",161,null],[12,"bang_token","","",161,null],[12,"delimiter","","",161,null],[12,"tokens","","",161,null],[4,"MacroDelimiter","","A grouping token that surrounds a macro body: m!(...) or …",null,null],[13,"Paren","","",162,null],[13,"Brace","","",162,null],[13,"Bracket","","",162,null],[4,"Data","","The storage of a struct, enum or union data structure.",null,null],[13,"Struct","","A struct input to a proc_macro_derive macro.",163,null],[13,"Enum","","An enum input to a proc_macro_derive macro.",163,null],[13,"Union","","An untagged union input to a proc_macro_derive macro.",163,null],[3,"DataEnum","","An enum input to a proc_macro_derive macro.",null,null],[12,"enum_token","","",164,null],[12,"brace_token","","",164,null],[12,"variants","","",164,null],[3,"DataStruct","","A struct input to a proc_macro_derive macro.",null,null],[12,"struct_token","","",165,null],[12,"fields","","",165,null],[12,"semi_token","","",165,null],[3,"DataUnion","","An untagged union input to a proc_macro_derive macro.",null,null],[12,"union_token","","",166,null],[12,"fields","","",166,null],[3,"DeriveInput","","Data structure sent to a proc_macro_derive macro.",null,null],[12,"attrs","","Attributes tagged on the whole struct or enum.",167,null],[12,"vis","","Visibility of the struct or enum.",167,null],[12,"ident","","Name of the struct or enum.",167,null],[12,"generics","","Generics required to complete the definition.",167,null],[12,"data","","Data within the struct or enum.",167,null],[4,"BinOp","","A binary operator: +, +=, &.",null,null],[13,"Add","","The + operator (addition)",168,null],[13,"Sub","","The - operator (subtraction)",168,null],[13,"Mul","","The * operator (multiplication)",168,null],[13,"Div","","The / operator (division)",168,null],[13,"Rem","","The % operator (modulus)",168,null],[13,"And","","The && operator (logical and)",168,null],[13,"Or","","The || operator (logical or)",168,null],[13,"BitXor","","The ^ operator (bitwise xor)",168,null],[13,"BitAnd","","The & operator (bitwise and)",168,null],[13,"BitOr","","The | operator (bitwise or)",168,null],[13,"Shl","","The << operator (shift left)",168,null],[13,"Shr","","The >> operator (shift right)",168,null],[13,"Eq","","The == operator (equality)",168,null],[13,"Lt","","The < operator (less than)",168,null],[13,"Le","","The <= operator (less than or equal to)",168,null],[13,"Ne","","The != operator (not equal to)",168,null],[13,"Ge","","The >= operator (greater than or equal to)",168,null],[13,"Gt","","The > operator (greater than)",168,null],[13,"AddEq","","The += operator",168,null],[13,"SubEq","","The -= operator",168,null],[13,"MulEq","","The *= operator",168,null],[13,"DivEq","","The /= operator",168,null],[13,"RemEq","","The %= operator",168,null],[13,"BitXorEq","","The ^= operator",168,null],[13,"BitAndEq","","The &= operator",168,null],[13,"BitOrEq","","The |= operator",168,null],[13,"ShlEq","","The <<= operator",168,null],[13,"ShrEq","","The >>= operator",168,null],[4,"UnOp","","A unary operator: *, !, -.",null,null],[13,"Deref","","The * operator for dereferencing",169,null],[13,"Not","","The ! operator for logical inversion",169,null],[13,"Neg","","The - operator for negation",169,null],[3,"Abi","","The binary interface of a function: extern \\\"C\\\".",null,null],[12,"extern_token","","",170,null],[12,"name","","",170,null],[3,"BareFnArg","","An argument in a function type: the usize in …",null,null],[12,"attrs","","",171,null],[12,"name","","",171,null],[12,"ty","","",171,null],[4,"ReturnType","","Return type of a function signature.",null,null],[13,"Default","","Return type is not specified.",172,null],[13,"Type","","A particular type is returned.",172,null],[4,"Type","","The possible types that a Rust value could have.",null,null],[13,"Array","","A fixed size array type: [T; n].",173,null],[13,"BareFn","","A bare function type: fn(usize) -> bool.",173,null],[13,"Group","","A type contained within invisible delimiters.",173,null],[13,"ImplTrait","","An impl Bound1 + Bound2 + Bound3 type where Bound is a …",173,null],[13,"Infer","","Indication that a type should be inferred by the …",173,null],[13,"Macro","","A macro in the type position.",173,null],[13,"Never","","The never type: !.",173,null],[13,"Paren","","A parenthesized type equivalent to the inner type.",173,null],[13,"Path","","A path like std::slice::Iter, optionally qualified with a …",173,null],[13,"Ptr","","A raw pointer type: *const T or *mut T.",173,null],[13,"Reference","","A reference type: &\'a T or &\'a mut T.",173,null],[13,"Slice","","A dynamically sized slice type: [T].",173,null],[13,"TraitObject","","A trait object type Bound1 + Bound2 + Bound3 where Bound …",173,null],[13,"Tuple","","A tuple type: (A, B, C, String).",173,null],[13,"Verbatim","","Tokens in type position not interpreted by Syn.",173,null],[3,"TypeArray","","A fixed size array type: [T; n].",null,null],[12,"bracket_token","","",174,null],[12,"elem","","",174,null],[12,"semi_token","","",174,null],[12,"len","","",174,null],[3,"TypeBareFn","","A bare function type: fn(usize) -> bool.",null,null],[12,"lifetimes","","",175,null],[12,"unsafety","","",175,null],[12,"abi","","",175,null],[12,"fn_token","","",175,null],[12,"paren_token","","",175,null],[12,"inputs","","",175,null],[12,"variadic","","",175,null],[12,"output","","",175,null],[3,"TypeGroup","","A type contained within invisible delimiters.",null,null],[12,"group_token","","",176,null],[12,"elem","","",176,null],[3,"TypeImplTrait","","An impl Bound1 + Bound2 + Bound3 type where Bound is a …",null,null],[12,"impl_token","","",177,null],[12,"bounds","","",177,null],[3,"TypeInfer","","Indication that a type should be inferred by the …",null,null],[12,"underscore_token","","",178,null],[3,"TypeMacro","","A macro in the type position.",null,null],[12,"mac","","",179,null],[3,"TypeNever","","The never type: !.",null,null],[12,"bang_token","","",180,null],[3,"TypeParen","","A parenthesized type equivalent to the inner type.",null,null],[12,"paren_token","","",181,null],[12,"elem","","",181,null],[3,"TypePath","","A path like std::slice::Iter, optionally qualified with a …",null,null],[12,"qself","","",182,null],[12,"path","","",182,null],[3,"TypePtr","","A raw pointer type: *const T or *mut T.",null,null],[12,"star_token","","",183,null],[12,"const_token","","",183,null],[12,"mutability","","",183,null],[12,"elem","","",183,null],[3,"TypeReference","","A reference type: &\'a T or &\'a mut T.",null,null],[12,"and_token","","",184,null],[12,"lifetime","","",184,null],[12,"mutability","","",184,null],[12,"elem","","",184,null],[3,"TypeSlice","","A dynamically sized slice type: [T].",null,null],[12,"bracket_token","","",185,null],[12,"elem","","",185,null],[3,"TypeTraitObject","","A trait object type Bound1 + Bound2 + Bound3 where Bound …",null,null],[12,"dyn_token","","",186,null],[12,"bounds","","",186,null],[3,"TypeTuple","","A tuple type: (A, B, C, String).",null,null],[12,"paren_token","","",187,null],[12,"elems","","",187,null],[3,"Variadic","","The variadic argument of a foreign function.",null,null],[12,"attrs","","",188,null],[12,"dots","","",188,null],[3,"AngleBracketedGenericArguments","","Angle bracketed arguments of a path segment: the …",null,null],[12,"colon2_token","","",189,null],[12,"lt_token","","",189,null],[12,"args","","",189,null],[12,"gt_token","","",189,null],[3,"Binding","","A binding (equality constraint) on an associated type: …",null,null],[12,"ident","","",190,null],[12,"eq_token","","",190,null],[12,"ty","","",190,null],[3,"Constraint","","An associated type bound: Iterator.",null,null],[12,"ident","","",191,null],[12,"colon_token","","",191,null],[12,"bounds","","",191,null],[4,"GenericArgument","","An individual generic argument, like \'a, T, or Item = T.",null,null],[13,"Lifetime","","A lifetime argument.",192,null],[13,"Type","","A type argument.",192,null],[13,"Binding","","A binding (equality constraint) on an associated type: …",192,null],[13,"Constraint","","An associated type bound: Iterator.",192,null],[13,"Const","","A const expression. Must be inside of a block.",192,null],[3,"ParenthesizedGenericArguments","","Arguments of a function path segment: the (A, B) -> C in …",null,null],[12,"paren_token","","",193,null],[12,"inputs","","(A, B)",193,null],[12,"output","","C",193,null],[3,"Path","","A path at which a named item is exported (e.g. …",null,null],[12,"leading_colon","","",194,null],[12,"segments","","",194,null],[4,"PathArguments","","Angle bracketed or parenthesized arguments of a path …",null,null],[13,"None","","",195,null],[13,"AngleBracketed","","The <\'a, T> in std::slice::iter<\'a, T>.",195,null],[13,"Parenthesized","","The (A, B) -> C in Fn(A, B) -> C.",195,null],[3,"PathSegment","","A segment of a path together with any path arguments on …",null,null],[12,"ident","","",196,null],[12,"arguments","","",196,null],[3,"QSelf","","The explicit Self type in a qualified path: the T in …",null,null],[12,"lt_token","","",197,null],[12,"ty","","",197,null],[12,"position","","",197,null],[12,"as_token","","",197,null],[12,"gt_token","","",197,null],[3,"Error","","Error returned when a Syn parser cannot parse the input …",null,null],[6,"Result","","The result of a Syn parser.",null,null],[5,"parse","","Parse tokens of source code into the chosen syntax tree …",null,[[["tokenstream",3]],[["result",6],["parse",8]]]],[5,"parse2","","Parse a proc-macro2 token stream into the chosen syntax …",null,[[["tokenstream",3]],[["result",6],["parse",8]]]],[5,"parse_str","","Parse a string of Rust code into the chosen syntax tree …",null,[[],[["result",6],["parse",8]]]],[14,"parenthesized","","Parse a set of parentheses and expose their content to …",null,null],[14,"braced","","Parse a set of curly braces and expose their content to …",null,null],[14,"bracketed","","Parse a set of square brackets and expose their content …",null,null],[14,"Token","","A type-macro that expands to the name of the Rust type …",null,null],[14,"parse_quote","","Quasi-quotation macro that accepts input like the quote! …",null,null],[14,"parse_macro_input","","Parse the input TokenStream of a macro, triggering a …",null,null],[14,"custom_keyword","","Define a type that supports parsing and printing a given …",null,null],[14,"custom_punctuation","","Define a type that supports parsing and printing a …",null,null],[11,"span","","",198,[[],["span",3]]],[11,"from","","",198,[[]]],[11,"into","","",198,[[]]],[11,"to_owned","","",198,[[]]],[11,"clone_into","","",198,[[]]],[11,"to_string","","",198,[[],["string",3]]],[11,"borrow","","",198,[[]]],[11,"borrow_mut","","",198,[[]]],[11,"try_from","","",198,[[],["result",4]]],[11,"try_into","","",198,[[],["result",4]]],[11,"type_id","","",198,[[],["typeid",3]]],[11,"span","syn::token","",0,[[],["span",3]]],[11,"from","","",0,[[]]],[11,"into","","",0,[[]]],[11,"to_owned","","",0,[[]]],[11,"clone_into","","",0,[[]]],[11,"borrow","","",0,[[]]],[11,"borrow_mut","","",0,[[]]],[11,"try_from","","",0,[[],["result",4]]],[11,"try_into","","",0,[[],["result",4]]],[11,"type_id","","",0,[[],["typeid",3]]],[11,"span","","",1,[[],["span",3]]],[11,"from","","",1,[[]]],[11,"into","","",1,[[]]],[11,"to_owned","","",1,[[]]],[11,"clone_into","","",1,[[]]],[11,"borrow","","",1,[[]]],[11,"borrow_mut","","",1,[[]]],[11,"try_from","","",1,[[],["result",4]]],[11,"try_into","","",1,[[],["result",4]]],[11,"type_id","","",1,[[],["typeid",3]]],[11,"span","","",2,[[],["span",3]]],[11,"from","","",2,[[]]],[11,"into","","",2,[[]]],[11,"to_owned","","",2,[[]]],[11,"clone_into","","",2,[[]]],[11,"borrow","","",2,[[]]],[11,"borrow_mut","","",2,[[]]],[11,"try_from","","",2,[[],["result",4]]],[11,"try_into","","",2,[[],["result",4]]],[11,"type_id","","",2,[[],["typeid",3]]],[11,"span","","",3,[[],["span",3]]],[11,"from","","",3,[[]]],[11,"into","","",3,[[]]],[11,"to_owned","","",3,[[]]],[11,"clone_into","","",3,[[]]],[11,"borrow","","",3,[[]]],[11,"borrow_mut","","",3,[[]]],[11,"try_from","","",3,[[],["result",4]]],[11,"try_into","","",3,[[],["result",4]]],[11,"type_id","","",3,[[],["typeid",3]]],[11,"span","","",4,[[],["span",3]]],[11,"from","","",4,[[]]],[11,"into","","",4,[[]]],[11,"to_owned","","",4,[[]]],[11,"clone_into","","",4,[[]]],[11,"borrow","","",4,[[]]],[11,"borrow_mut","","",4,[[]]],[11,"try_from","","",4,[[],["result",4]]],[11,"try_into","","",4,[[],["result",4]]],[11,"type_id","","",4,[[],["typeid",3]]],[11,"span","","",5,[[],["span",3]]],[11,"from","","",5,[[]]],[11,"into","","",5,[[]]],[11,"to_owned","","",5,[[]]],[11,"clone_into","","",5,[[]]],[11,"borrow","","",5,[[]]],[11,"borrow_mut","","",5,[[]]],[11,"try_from","","",5,[[],["result",4]]],[11,"try_into","","",5,[[],["result",4]]],[11,"type_id","","",5,[[],["typeid",3]]],[11,"span","","",6,[[],["span",3]]],[11,"from","","",6,[[]]],[11,"into","","",6,[[]]],[11,"to_owned","","",6,[[]]],[11,"clone_into","","",6,[[]]],[11,"borrow","","",6,[[]]],[11,"borrow_mut","","",6,[[]]],[11,"try_from","","",6,[[],["result",4]]],[11,"try_into","","",6,[[],["result",4]]],[11,"type_id","","",6,[[],["typeid",3]]],[11,"span","","",7,[[],["span",3]]],[11,"from","","",7,[[]]],[11,"into","","",7,[[]]],[11,"to_owned","","",7,[[]]],[11,"clone_into","","",7,[[]]],[11,"borrow","","",7,[[]]],[11,"borrow_mut","","",7,[[]]],[11,"try_from","","",7,[[],["result",4]]],[11,"try_into","","",7,[[],["result",4]]],[11,"type_id","","",7,[[],["typeid",3]]],[11,"span","","",8,[[],["span",3]]],[11,"from","","",8,[[]]],[11,"into","","",8,[[]]],[11,"to_owned","","",8,[[]]],[11,"clone_into","","",8,[[]]],[11,"borrow","","",8,[[]]],[11,"borrow_mut","","",8,[[]]],[11,"try_from","","",8,[[],["result",4]]],[11,"try_into","","",8,[[],["result",4]]],[11,"type_id","","",8,[[],["typeid",3]]],[11,"span","","",9,[[],["span",3]]],[11,"from","","",9,[[]]],[11,"into","","",9,[[]]],[11,"to_owned","","",9,[[]]],[11,"clone_into","","",9,[[]]],[11,"borrow","","",9,[[]]],[11,"borrow_mut","","",9,[[]]],[11,"try_from","","",9,[[],["result",4]]],[11,"try_into","","",9,[[],["result",4]]],[11,"type_id","","",9,[[],["typeid",3]]],[11,"span","","",10,[[],["span",3]]],[11,"from","","",10,[[]]],[11,"into","","",10,[[]]],[11,"to_owned","","",10,[[]]],[11,"clone_into","","",10,[[]]],[11,"borrow","","",10,[[]]],[11,"borrow_mut","","",10,[[]]],[11,"try_from","","",10,[[],["result",4]]],[11,"try_into","","",10,[[],["result",4]]],[11,"type_id","","",10,[[],["typeid",3]]],[11,"span","","",11,[[],["span",3]]],[11,"from","","",11,[[]]],[11,"into","","",11,[[]]],[11,"to_owned","","",11,[[]]],[11,"clone_into","","",11,[[]]],[11,"borrow","","",11,[[]]],[11,"borrow_mut","","",11,[[]]],[11,"try_from","","",11,[[],["result",4]]],[11,"try_into","","",11,[[],["result",4]]],[11,"type_id","","",11,[[],["typeid",3]]],[11,"span","","",12,[[],["span",3]]],[11,"from","","",12,[[]]],[11,"into","","",12,[[]]],[11,"to_owned","","",12,[[]]],[11,"clone_into","","",12,[[]]],[11,"borrow","","",12,[[]]],[11,"borrow_mut","","",12,[[]]],[11,"try_from","","",12,[[],["result",4]]],[11,"try_into","","",12,[[],["result",4]]],[11,"type_id","","",12,[[],["typeid",3]]],[11,"span","","",13,[[],["span",3]]],[11,"from","","",13,[[]]],[11,"into","","",13,[[]]],[11,"to_owned","","",13,[[]]],[11,"clone_into","","",13,[[]]],[11,"borrow","","",13,[[]]],[11,"borrow_mut","","",13,[[]]],[11,"try_from","","",13,[[],["result",4]]],[11,"try_into","","",13,[[],["result",4]]],[11,"type_id","","",13,[[],["typeid",3]]],[11,"span","","",14,[[],["span",3]]],[11,"from","","",14,[[]]],[11,"into","","",14,[[]]],[11,"to_owned","","",14,[[]]],[11,"clone_into","","",14,[[]]],[11,"borrow","","",14,[[]]],[11,"borrow_mut","","",14,[[]]],[11,"try_from","","",14,[[],["result",4]]],[11,"try_into","","",14,[[],["result",4]]],[11,"type_id","","",14,[[],["typeid",3]]],[11,"span","","",15,[[],["span",3]]],[11,"from","","",15,[[]]],[11,"into","","",15,[[]]],[11,"to_owned","","",15,[[]]],[11,"clone_into","","",15,[[]]],[11,"borrow","","",15,[[]]],[11,"borrow_mut","","",15,[[]]],[11,"try_from","","",15,[[],["result",4]]],[11,"try_into","","",15,[[],["result",4]]],[11,"type_id","","",15,[[],["typeid",3]]],[11,"span","","",16,[[],["span",3]]],[11,"from","","",16,[[]]],[11,"into","","",16,[[]]],[11,"to_owned","","",16,[[]]],[11,"clone_into","","",16,[[]]],[11,"borrow","","",16,[[]]],[11,"borrow_mut","","",16,[[]]],[11,"try_from","","",16,[[],["result",4]]],[11,"try_into","","",16,[[],["result",4]]],[11,"type_id","","",16,[[],["typeid",3]]],[11,"span","","",17,[[],["span",3]]],[11,"from","","",17,[[]]],[11,"into","","",17,[[]]],[11,"to_owned","","",17,[[]]],[11,"clone_into","","",17,[[]]],[11,"borrow","","",17,[[]]],[11,"borrow_mut","","",17,[[]]],[11,"try_from","","",17,[[],["result",4]]],[11,"try_into","","",17,[[],["result",4]]],[11,"type_id","","",17,[[],["typeid",3]]],[11,"span","","",18,[[],["span",3]]],[11,"from","","",18,[[]]],[11,"into","","",18,[[]]],[11,"to_owned","","",18,[[]]],[11,"clone_into","","",18,[[]]],[11,"borrow","","",18,[[]]],[11,"borrow_mut","","",18,[[]]],[11,"try_from","","",18,[[],["result",4]]],[11,"try_into","","",18,[[],["result",4]]],[11,"type_id","","",18,[[],["typeid",3]]],[11,"span","","",19,[[],["span",3]]],[11,"from","","",19,[[]]],[11,"into","","",19,[[]]],[11,"to_owned","","",19,[[]]],[11,"clone_into","","",19,[[]]],[11,"borrow","","",19,[[]]],[11,"borrow_mut","","",19,[[]]],[11,"try_from","","",19,[[],["result",4]]],[11,"try_into","","",19,[[],["result",4]]],[11,"type_id","","",19,[[],["typeid",3]]],[11,"span","","",20,[[],["span",3]]],[11,"from","","",20,[[]]],[11,"into","","",20,[[]]],[11,"to_owned","","",20,[[]]],[11,"clone_into","","",20,[[]]],[11,"borrow","","",20,[[]]],[11,"borrow_mut","","",20,[[]]],[11,"try_from","","",20,[[],["result",4]]],[11,"try_into","","",20,[[],["result",4]]],[11,"type_id","","",20,[[],["typeid",3]]],[11,"span","","",21,[[],["span",3]]],[11,"from","","",21,[[]]],[11,"into","","",21,[[]]],[11,"to_owned","","",21,[[]]],[11,"clone_into","","",21,[[]]],[11,"borrow","","",21,[[]]],[11,"borrow_mut","","",21,[[]]],[11,"try_from","","",21,[[],["result",4]]],[11,"try_into","","",21,[[],["result",4]]],[11,"type_id","","",21,[[],["typeid",3]]],[11,"span","","",22,[[],["span",3]]],[11,"from","","",22,[[]]],[11,"into","","",22,[[]]],[11,"to_owned","","",22,[[]]],[11,"clone_into","","",22,[[]]],[11,"borrow","","",22,[[]]],[11,"borrow_mut","","",22,[[]]],[11,"try_from","","",22,[[],["result",4]]],[11,"try_into","","",22,[[],["result",4]]],[11,"type_id","","",22,[[],["typeid",3]]],[11,"span","","",23,[[],["span",3]]],[11,"from","","",23,[[]]],[11,"into","","",23,[[]]],[11,"to_owned","","",23,[[]]],[11,"clone_into","","",23,[[]]],[11,"borrow","","",23,[[]]],[11,"borrow_mut","","",23,[[]]],[11,"try_from","","",23,[[],["result",4]]],[11,"try_into","","",23,[[],["result",4]]],[11,"type_id","","",23,[[],["typeid",3]]],[11,"span","","",24,[[],["span",3]]],[11,"from","","",24,[[]]],[11,"into","","",24,[[]]],[11,"to_owned","","",24,[[]]],[11,"clone_into","","",24,[[]]],[11,"borrow","","",24,[[]]],[11,"borrow_mut","","",24,[[]]],[11,"try_from","","",24,[[],["result",4]]],[11,"try_into","","",24,[[],["result",4]]],[11,"type_id","","",24,[[],["typeid",3]]],[11,"span","","",25,[[],["span",3]]],[11,"from","","",25,[[]]],[11,"into","","",25,[[]]],[11,"to_owned","","",25,[[]]],[11,"clone_into","","",25,[[]]],[11,"borrow","","",25,[[]]],[11,"borrow_mut","","",25,[[]]],[11,"try_from","","",25,[[],["result",4]]],[11,"try_into","","",25,[[],["result",4]]],[11,"type_id","","",25,[[],["typeid",3]]],[11,"span","","",26,[[],["span",3]]],[11,"from","","",26,[[]]],[11,"into","","",26,[[]]],[11,"to_owned","","",26,[[]]],[11,"clone_into","","",26,[[]]],[11,"borrow","","",26,[[]]],[11,"borrow_mut","","",26,[[]]],[11,"try_from","","",26,[[],["result",4]]],[11,"try_into","","",26,[[],["result",4]]],[11,"type_id","","",26,[[],["typeid",3]]],[11,"span","","",27,[[],["span",3]]],[11,"from","","",27,[[]]],[11,"into","","",27,[[]]],[11,"to_owned","","",27,[[]]],[11,"clone_into","","",27,[[]]],[11,"borrow","","",27,[[]]],[11,"borrow_mut","","",27,[[]]],[11,"try_from","","",27,[[],["result",4]]],[11,"try_into","","",27,[[],["result",4]]],[11,"type_id","","",27,[[],["typeid",3]]],[11,"span","","",28,[[],["span",3]]],[11,"from","","",28,[[]]],[11,"into","","",28,[[]]],[11,"to_owned","","",28,[[]]],[11,"clone_into","","",28,[[]]],[11,"borrow","","",28,[[]]],[11,"borrow_mut","","",28,[[]]],[11,"try_from","","",28,[[],["result",4]]],[11,"try_into","","",28,[[],["result",4]]],[11,"type_id","","",28,[[],["typeid",3]]],[11,"span","","",29,[[],["span",3]]],[11,"from","","",29,[[]]],[11,"into","","",29,[[]]],[11,"to_owned","","",29,[[]]],[11,"clone_into","","",29,[[]]],[11,"borrow","","",29,[[]]],[11,"borrow_mut","","",29,[[]]],[11,"try_from","","",29,[[],["result",4]]],[11,"try_into","","",29,[[],["result",4]]],[11,"type_id","","",29,[[],["typeid",3]]],[11,"span","","",30,[[],["span",3]]],[11,"from","","",30,[[]]],[11,"into","","",30,[[]]],[11,"to_owned","","",30,[[]]],[11,"clone_into","","",30,[[]]],[11,"borrow","","",30,[[]]],[11,"borrow_mut","","",30,[[]]],[11,"try_from","","",30,[[],["result",4]]],[11,"try_into","","",30,[[],["result",4]]],[11,"type_id","","",30,[[],["typeid",3]]],[11,"span","","",31,[[],["span",3]]],[11,"from","","",31,[[]]],[11,"into","","",31,[[]]],[11,"to_owned","","",31,[[]]],[11,"clone_into","","",31,[[]]],[11,"borrow","","",31,[[]]],[11,"borrow_mut","","",31,[[]]],[11,"try_from","","",31,[[],["result",4]]],[11,"try_into","","",31,[[],["result",4]]],[11,"type_id","","",31,[[],["typeid",3]]],[11,"span","","",32,[[],["span",3]]],[11,"from","","",32,[[]]],[11,"into","","",32,[[]]],[11,"to_owned","","",32,[[]]],[11,"clone_into","","",32,[[]]],[11,"borrow","","",32,[[]]],[11,"borrow_mut","","",32,[[]]],[11,"try_from","","",32,[[],["result",4]]],[11,"try_into","","",32,[[],["result",4]]],[11,"type_id","","",32,[[],["typeid",3]]],[11,"span","","",33,[[],["span",3]]],[11,"from","","",33,[[]]],[11,"into","","",33,[[]]],[11,"to_owned","","",33,[[]]],[11,"clone_into","","",33,[[]]],[11,"borrow","","",33,[[]]],[11,"borrow_mut","","",33,[[]]],[11,"try_from","","",33,[[],["result",4]]],[11,"try_into","","",33,[[],["result",4]]],[11,"type_id","","",33,[[],["typeid",3]]],[11,"span","","",34,[[],["span",3]]],[11,"from","","",34,[[]]],[11,"into","","",34,[[]]],[11,"to_owned","","",34,[[]]],[11,"clone_into","","",34,[[]]],[11,"borrow","","",34,[[]]],[11,"borrow_mut","","",34,[[]]],[11,"try_from","","",34,[[],["result",4]]],[11,"try_into","","",34,[[],["result",4]]],[11,"type_id","","",34,[[],["typeid",3]]],[11,"span","","",35,[[],["span",3]]],[11,"from","","",35,[[]]],[11,"into","","",35,[[]]],[11,"to_owned","","",35,[[]]],[11,"clone_into","","",35,[[]]],[11,"borrow","","",35,[[]]],[11,"borrow_mut","","",35,[[]]],[11,"try_from","","",35,[[],["result",4]]],[11,"try_into","","",35,[[],["result",4]]],[11,"type_id","","",35,[[],["typeid",3]]],[11,"span","","",36,[[],["span",3]]],[11,"from","","",36,[[]]],[11,"into","","",36,[[]]],[11,"to_owned","","",36,[[]]],[11,"clone_into","","",36,[[]]],[11,"borrow","","",36,[[]]],[11,"borrow_mut","","",36,[[]]],[11,"try_from","","",36,[[],["result",4]]],[11,"try_into","","",36,[[],["result",4]]],[11,"type_id","","",36,[[],["typeid",3]]],[11,"span","","",37,[[],["span",3]]],[11,"from","","",37,[[]]],[11,"into","","",37,[[]]],[11,"to_owned","","",37,[[]]],[11,"clone_into","","",37,[[]]],[11,"borrow","","",37,[[]]],[11,"borrow_mut","","",37,[[]]],[11,"try_from","","",37,[[],["result",4]]],[11,"try_into","","",37,[[],["result",4]]],[11,"type_id","","",37,[[],["typeid",3]]],[11,"span","","",38,[[],["span",3]]],[11,"from","","",38,[[]]],[11,"into","","",38,[[]]],[11,"to_owned","","",38,[[]]],[11,"clone_into","","",38,[[]]],[11,"borrow","","",38,[[]]],[11,"borrow_mut","","",38,[[]]],[11,"try_from","","",38,[[],["result",4]]],[11,"try_into","","",38,[[],["result",4]]],[11,"type_id","","",38,[[],["typeid",3]]],[11,"span","","",39,[[],["span",3]]],[11,"from","","",39,[[]]],[11,"into","","",39,[[]]],[11,"to_owned","","",39,[[]]],[11,"clone_into","","",39,[[]]],[11,"borrow","","",39,[[]]],[11,"borrow_mut","","",39,[[]]],[11,"try_from","","",39,[[],["result",4]]],[11,"try_into","","",39,[[],["result",4]]],[11,"type_id","","",39,[[],["typeid",3]]],[11,"span","","",40,[[],["span",3]]],[11,"from","","",40,[[]]],[11,"into","","",40,[[]]],[11,"to_owned","","",40,[[]]],[11,"clone_into","","",40,[[]]],[11,"borrow","","",40,[[]]],[11,"borrow_mut","","",40,[[]]],[11,"try_from","","",40,[[],["result",4]]],[11,"try_into","","",40,[[],["result",4]]],[11,"type_id","","",40,[[],["typeid",3]]],[11,"span","","",41,[[],["span",3]]],[11,"from","","",41,[[]]],[11,"into","","",41,[[]]],[11,"to_owned","","",41,[[]]],[11,"clone_into","","",41,[[]]],[11,"borrow","","",41,[[]]],[11,"borrow_mut","","",41,[[]]],[11,"try_from","","",41,[[],["result",4]]],[11,"try_into","","",41,[[],["result",4]]],[11,"type_id","","",41,[[],["typeid",3]]],[11,"span","","",42,[[],["span",3]]],[11,"from","","",42,[[]]],[11,"into","","",42,[[]]],[11,"to_owned","","",42,[[]]],[11,"clone_into","","",42,[[]]],[11,"borrow","","",42,[[]]],[11,"borrow_mut","","",42,[[]]],[11,"try_from","","",42,[[],["result",4]]],[11,"try_into","","",42,[[],["result",4]]],[11,"type_id","","",42,[[],["typeid",3]]],[11,"span","","",43,[[],["span",3]]],[11,"from","","",43,[[]]],[11,"into","","",43,[[]]],[11,"to_owned","","",43,[[]]],[11,"clone_into","","",43,[[]]],[11,"borrow","","",43,[[]]],[11,"borrow_mut","","",43,[[]]],[11,"try_from","","",43,[[],["result",4]]],[11,"try_into","","",43,[[],["result",4]]],[11,"type_id","","",43,[[],["typeid",3]]],[11,"span","","",44,[[],["span",3]]],[11,"from","","",44,[[]]],[11,"into","","",44,[[]]],[11,"to_owned","","",44,[[]]],[11,"clone_into","","",44,[[]]],[11,"borrow","","",44,[[]]],[11,"borrow_mut","","",44,[[]]],[11,"try_from","","",44,[[],["result",4]]],[11,"try_into","","",44,[[],["result",4]]],[11,"type_id","","",44,[[],["typeid",3]]],[11,"span","","",45,[[],["span",3]]],[11,"from","","",45,[[]]],[11,"into","","",45,[[]]],[11,"to_owned","","",45,[[]]],[11,"clone_into","","",45,[[]]],[11,"borrow","","",45,[[]]],[11,"borrow_mut","","",45,[[]]],[11,"try_from","","",45,[[],["result",4]]],[11,"try_into","","",45,[[],["result",4]]],[11,"type_id","","",45,[[],["typeid",3]]],[11,"span","","",46,[[],["span",3]]],[11,"from","","",46,[[]]],[11,"into","","",46,[[]]],[11,"to_owned","","",46,[[]]],[11,"clone_into","","",46,[[]]],[11,"borrow","","",46,[[]]],[11,"borrow_mut","","",46,[[]]],[11,"try_from","","",46,[[],["result",4]]],[11,"try_into","","",46,[[],["result",4]]],[11,"type_id","","",46,[[],["typeid",3]]],[11,"span","","",47,[[],["span",3]]],[11,"from","","",47,[[]]],[11,"into","","",47,[[]]],[11,"to_owned","","",47,[[]]],[11,"clone_into","","",47,[[]]],[11,"borrow","","",47,[[]]],[11,"borrow_mut","","",47,[[]]],[11,"try_from","","",47,[[],["result",4]]],[11,"try_into","","",47,[[],["result",4]]],[11,"type_id","","",47,[[],["typeid",3]]],[11,"span","","",48,[[],["span",3]]],[11,"from","","",48,[[]]],[11,"into","","",48,[[]]],[11,"to_owned","","",48,[[]]],[11,"clone_into","","",48,[[]]],[11,"borrow","","",48,[[]]],[11,"borrow_mut","","",48,[[]]],[11,"try_from","","",48,[[],["result",4]]],[11,"try_into","","",48,[[],["result",4]]],[11,"type_id","","",48,[[],["typeid",3]]],[11,"span","","",49,[[],["span",3]]],[11,"from","","",49,[[]]],[11,"into","","",49,[[]]],[11,"to_owned","","",49,[[]]],[11,"clone_into","","",49,[[]]],[11,"borrow","","",49,[[]]],[11,"borrow_mut","","",49,[[]]],[11,"try_from","","",49,[[],["result",4]]],[11,"try_into","","",49,[[],["result",4]]],[11,"type_id","","",49,[[],["typeid",3]]],[11,"span","","",50,[[],["span",3]]],[11,"from","","",50,[[]]],[11,"into","","",50,[[]]],[11,"to_owned","","",50,[[]]],[11,"clone_into","","",50,[[]]],[11,"borrow","","",50,[[]]],[11,"borrow_mut","","",50,[[]]],[11,"try_from","","",50,[[],["result",4]]],[11,"try_into","","",50,[[],["result",4]]],[11,"type_id","","",50,[[],["typeid",3]]],[11,"span","","",51,[[],["span",3]]],[11,"from","","",51,[[]]],[11,"into","","",51,[[]]],[11,"to_owned","","",51,[[]]],[11,"clone_into","","",51,[[]]],[11,"borrow","","",51,[[]]],[11,"borrow_mut","","",51,[[]]],[11,"try_from","","",51,[[],["result",4]]],[11,"try_into","","",51,[[],["result",4]]],[11,"type_id","","",51,[[],["typeid",3]]],[11,"span","","",52,[[],["span",3]]],[11,"from","","",52,[[]]],[11,"into","","",52,[[]]],[11,"to_owned","","",52,[[]]],[11,"clone_into","","",52,[[]]],[11,"borrow","","",52,[[]]],[11,"borrow_mut","","",52,[[]]],[11,"try_from","","",52,[[],["result",4]]],[11,"try_into","","",52,[[],["result",4]]],[11,"type_id","","",52,[[],["typeid",3]]],[11,"span","","",53,[[],["span",3]]],[11,"from","","",53,[[]]],[11,"into","","",53,[[]]],[11,"to_owned","","",53,[[]]],[11,"clone_into","","",53,[[]]],[11,"borrow","","",53,[[]]],[11,"borrow_mut","","",53,[[]]],[11,"try_from","","",53,[[],["result",4]]],[11,"try_into","","",53,[[],["result",4]]],[11,"type_id","","",53,[[],["typeid",3]]],[11,"span","","",54,[[],["span",3]]],[11,"from","","",54,[[]]],[11,"into","","",54,[[]]],[11,"to_owned","","",54,[[]]],[11,"clone_into","","",54,[[]]],[11,"borrow","","",54,[[]]],[11,"borrow_mut","","",54,[[]]],[11,"try_from","","",54,[[],["result",4]]],[11,"try_into","","",54,[[],["result",4]]],[11,"type_id","","",54,[[],["typeid",3]]],[11,"span","","",55,[[],["span",3]]],[11,"from","","",55,[[]]],[11,"into","","",55,[[]]],[11,"to_owned","","",55,[[]]],[11,"clone_into","","",55,[[]]],[11,"borrow","","",55,[[]]],[11,"borrow_mut","","",55,[[]]],[11,"try_from","","",55,[[],["result",4]]],[11,"try_into","","",55,[[],["result",4]]],[11,"type_id","","",55,[[],["typeid",3]]],[11,"span","","",56,[[],["span",3]]],[11,"from","","",56,[[]]],[11,"into","","",56,[[]]],[11,"to_owned","","",56,[[]]],[11,"clone_into","","",56,[[]]],[11,"borrow","","",56,[[]]],[11,"borrow_mut","","",56,[[]]],[11,"try_from","","",56,[[],["result",4]]],[11,"try_into","","",56,[[],["result",4]]],[11,"type_id","","",56,[[],["typeid",3]]],[11,"span","","",57,[[],["span",3]]],[11,"from","","",57,[[]]],[11,"into","","",57,[[]]],[11,"to_owned","","",57,[[]]],[11,"clone_into","","",57,[[]]],[11,"borrow","","",57,[[]]],[11,"borrow_mut","","",57,[[]]],[11,"try_from","","",57,[[],["result",4]]],[11,"try_into","","",57,[[],["result",4]]],[11,"type_id","","",57,[[],["typeid",3]]],[11,"span","","",58,[[],["span",3]]],[11,"from","","",58,[[]]],[11,"into","","",58,[[]]],[11,"to_owned","","",58,[[]]],[11,"clone_into","","",58,[[]]],[11,"borrow","","",58,[[]]],[11,"borrow_mut","","",58,[[]]],[11,"try_from","","",58,[[],["result",4]]],[11,"try_into","","",58,[[],["result",4]]],[11,"type_id","","",58,[[],["typeid",3]]],[11,"span","","",59,[[],["span",3]]],[11,"from","","",59,[[]]],[11,"into","","",59,[[]]],[11,"to_owned","","",59,[[]]],[11,"clone_into","","",59,[[]]],[11,"borrow","","",59,[[]]],[11,"borrow_mut","","",59,[[]]],[11,"try_from","","",59,[[],["result",4]]],[11,"try_into","","",59,[[],["result",4]]],[11,"type_id","","",59,[[],["typeid",3]]],[11,"span","","",60,[[],["span",3]]],[11,"from","","",60,[[]]],[11,"into","","",60,[[]]],[11,"to_owned","","",60,[[]]],[11,"clone_into","","",60,[[]]],[11,"borrow","","",60,[[]]],[11,"borrow_mut","","",60,[[]]],[11,"try_from","","",60,[[],["result",4]]],[11,"try_into","","",60,[[],["result",4]]],[11,"type_id","","",60,[[],["typeid",3]]],[11,"span","","",61,[[],["span",3]]],[11,"from","","",61,[[]]],[11,"into","","",61,[[]]],[11,"to_owned","","",61,[[]]],[11,"clone_into","","",61,[[]]],[11,"borrow","","",61,[[]]],[11,"borrow_mut","","",61,[[]]],[11,"try_from","","",61,[[],["result",4]]],[11,"try_into","","",61,[[],["result",4]]],[11,"type_id","","",61,[[],["typeid",3]]],[11,"span","","",62,[[],["span",3]]],[11,"from","","",62,[[]]],[11,"into","","",62,[[]]],[11,"to_owned","","",62,[[]]],[11,"clone_into","","",62,[[]]],[11,"borrow","","",62,[[]]],[11,"borrow_mut","","",62,[[]]],[11,"try_from","","",62,[[],["result",4]]],[11,"try_into","","",62,[[],["result",4]]],[11,"type_id","","",62,[[],["typeid",3]]],[11,"span","","",63,[[],["span",3]]],[11,"from","","",63,[[]]],[11,"into","","",63,[[]]],[11,"to_owned","","",63,[[]]],[11,"clone_into","","",63,[[]]],[11,"borrow","","",63,[[]]],[11,"borrow_mut","","",63,[[]]],[11,"try_from","","",63,[[],["result",4]]],[11,"try_into","","",63,[[],["result",4]]],[11,"type_id","","",63,[[],["typeid",3]]],[11,"span","","",64,[[],["span",3]]],[11,"from","","",64,[[]]],[11,"into","","",64,[[]]],[11,"to_owned","","",64,[[]]],[11,"clone_into","","",64,[[]]],[11,"borrow","","",64,[[]]],[11,"borrow_mut","","",64,[[]]],[11,"try_from","","",64,[[],["result",4]]],[11,"try_into","","",64,[[],["result",4]]],[11,"type_id","","",64,[[],["typeid",3]]],[11,"span","","",65,[[],["span",3]]],[11,"from","","",65,[[]]],[11,"into","","",65,[[]]],[11,"to_owned","","",65,[[]]],[11,"clone_into","","",65,[[]]],[11,"borrow","","",65,[[]]],[11,"borrow_mut","","",65,[[]]],[11,"try_from","","",65,[[],["result",4]]],[11,"try_into","","",65,[[],["result",4]]],[11,"type_id","","",65,[[],["typeid",3]]],[11,"span","","",66,[[],["span",3]]],[11,"from","","",66,[[]]],[11,"into","","",66,[[]]],[11,"to_owned","","",66,[[]]],[11,"clone_into","","",66,[[]]],[11,"borrow","","",66,[[]]],[11,"borrow_mut","","",66,[[]]],[11,"try_from","","",66,[[],["result",4]]],[11,"try_into","","",66,[[],["result",4]]],[11,"type_id","","",66,[[],["typeid",3]]],[11,"span","","",67,[[],["span",3]]],[11,"from","","",67,[[]]],[11,"into","","",67,[[]]],[11,"to_owned","","",67,[[]]],[11,"clone_into","","",67,[[]]],[11,"borrow","","",67,[[]]],[11,"borrow_mut","","",67,[[]]],[11,"try_from","","",67,[[],["result",4]]],[11,"try_into","","",67,[[],["result",4]]],[11,"type_id","","",67,[[],["typeid",3]]],[11,"span","","",68,[[],["span",3]]],[11,"from","","",68,[[]]],[11,"into","","",68,[[]]],[11,"to_owned","","",68,[[]]],[11,"clone_into","","",68,[[]]],[11,"borrow","","",68,[[]]],[11,"borrow_mut","","",68,[[]]],[11,"try_from","","",68,[[],["result",4]]],[11,"try_into","","",68,[[],["result",4]]],[11,"type_id","","",68,[[],["typeid",3]]],[11,"span","","",69,[[],["span",3]]],[11,"from","","",69,[[]]],[11,"into","","",69,[[]]],[11,"to_owned","","",69,[[]]],[11,"clone_into","","",69,[[]]],[11,"borrow","","",69,[[]]],[11,"borrow_mut","","",69,[[]]],[11,"try_from","","",69,[[],["result",4]]],[11,"try_into","","",69,[[],["result",4]]],[11,"type_id","","",69,[[],["typeid",3]]],[11,"span","","",70,[[],["span",3]]],[11,"from","","",70,[[]]],[11,"into","","",70,[[]]],[11,"to_owned","","",70,[[]]],[11,"clone_into","","",70,[[]]],[11,"borrow","","",70,[[]]],[11,"borrow_mut","","",70,[[]]],[11,"try_from","","",70,[[],["result",4]]],[11,"try_into","","",70,[[],["result",4]]],[11,"type_id","","",70,[[],["typeid",3]]],[11,"span","","",71,[[],["span",3]]],[11,"from","","",71,[[]]],[11,"into","","",71,[[]]],[11,"to_owned","","",71,[[]]],[11,"clone_into","","",71,[[]]],[11,"borrow","","",71,[[]]],[11,"borrow_mut","","",71,[[]]],[11,"try_from","","",71,[[],["result",4]]],[11,"try_into","","",71,[[],["result",4]]],[11,"type_id","","",71,[[],["typeid",3]]],[11,"span","","",72,[[],["span",3]]],[11,"from","","",72,[[]]],[11,"into","","",72,[[]]],[11,"to_owned","","",72,[[]]],[11,"clone_into","","",72,[[]]],[11,"borrow","","",72,[[]]],[11,"borrow_mut","","",72,[[]]],[11,"try_from","","",72,[[],["result",4]]],[11,"try_into","","",72,[[],["result",4]]],[11,"type_id","","",72,[[],["typeid",3]]],[11,"span","","",73,[[],["span",3]]],[11,"from","","",73,[[]]],[11,"into","","",73,[[]]],[11,"to_owned","","",73,[[]]],[11,"clone_into","","",73,[[]]],[11,"borrow","","",73,[[]]],[11,"borrow_mut","","",73,[[]]],[11,"try_from","","",73,[[],["result",4]]],[11,"try_into","","",73,[[],["result",4]]],[11,"type_id","","",73,[[],["typeid",3]]],[11,"span","","",74,[[],["span",3]]],[11,"from","","",74,[[]]],[11,"into","","",74,[[]]],[11,"to_owned","","",74,[[]]],[11,"clone_into","","",74,[[]]],[11,"borrow","","",74,[[]]],[11,"borrow_mut","","",74,[[]]],[11,"try_from","","",74,[[],["result",4]]],[11,"try_into","","",74,[[],["result",4]]],[11,"type_id","","",74,[[],["typeid",3]]],[11,"span","","",75,[[],["span",3]]],[11,"from","","",75,[[]]],[11,"into","","",75,[[]]],[11,"to_owned","","",75,[[]]],[11,"clone_into","","",75,[[]]],[11,"borrow","","",75,[[]]],[11,"borrow_mut","","",75,[[]]],[11,"try_from","","",75,[[],["result",4]]],[11,"try_into","","",75,[[],["result",4]]],[11,"type_id","","",75,[[],["typeid",3]]],[11,"span","","",76,[[],["span",3]]],[11,"from","","",76,[[]]],[11,"into","","",76,[[]]],[11,"to_owned","","",76,[[]]],[11,"clone_into","","",76,[[]]],[11,"borrow","","",76,[[]]],[11,"borrow_mut","","",76,[[]]],[11,"try_from","","",76,[[],["result",4]]],[11,"try_into","","",76,[[],["result",4]]],[11,"type_id","","",76,[[],["typeid",3]]],[11,"span","","",77,[[],["span",3]]],[11,"from","","",77,[[]]],[11,"into","","",77,[[]]],[11,"to_owned","","",77,[[]]],[11,"clone_into","","",77,[[]]],[11,"borrow","","",77,[[]]],[11,"borrow_mut","","",77,[[]]],[11,"try_from","","",77,[[],["result",4]]],[11,"try_into","","",77,[[],["result",4]]],[11,"type_id","","",77,[[],["typeid",3]]],[11,"span","","",78,[[],["span",3]]],[11,"from","","",78,[[]]],[11,"into","","",78,[[]]],[11,"to_owned","","",78,[[]]],[11,"clone_into","","",78,[[]]],[11,"borrow","","",78,[[]]],[11,"borrow_mut","","",78,[[]]],[11,"try_from","","",78,[[],["result",4]]],[11,"try_into","","",78,[[],["result",4]]],[11,"type_id","","",78,[[],["typeid",3]]],[11,"span","","",79,[[],["span",3]]],[11,"from","","",79,[[]]],[11,"into","","",79,[[]]],[11,"to_owned","","",79,[[]]],[11,"clone_into","","",79,[[]]],[11,"borrow","","",79,[[]]],[11,"borrow_mut","","",79,[[]]],[11,"try_from","","",79,[[],["result",4]]],[11,"try_into","","",79,[[],["result",4]]],[11,"type_id","","",79,[[],["typeid",3]]],[11,"span","","",80,[[],["span",3]]],[11,"from","","",80,[[]]],[11,"into","","",80,[[]]],[11,"to_owned","","",80,[[]]],[11,"clone_into","","",80,[[]]],[11,"borrow","","",80,[[]]],[11,"borrow_mut","","",80,[[]]],[11,"try_from","","",80,[[],["result",4]]],[11,"try_into","","",80,[[],["result",4]]],[11,"type_id","","",80,[[],["typeid",3]]],[11,"span","","",81,[[],["span",3]]],[11,"from","","",81,[[]]],[11,"into","","",81,[[]]],[11,"to_owned","","",81,[[]]],[11,"clone_into","","",81,[[]]],[11,"borrow","","",81,[[]]],[11,"borrow_mut","","",81,[[]]],[11,"try_from","","",81,[[],["result",4]]],[11,"try_into","","",81,[[],["result",4]]],[11,"type_id","","",81,[[],["typeid",3]]],[11,"span","","",82,[[],["span",3]]],[11,"from","","",82,[[]]],[11,"into","","",82,[[]]],[11,"to_owned","","",82,[[]]],[11,"clone_into","","",82,[[]]],[11,"borrow","","",82,[[]]],[11,"borrow_mut","","",82,[[]]],[11,"try_from","","",82,[[],["result",4]]],[11,"try_into","","",82,[[],["result",4]]],[11,"type_id","","",82,[[],["typeid",3]]],[11,"span","","",83,[[],["span",3]]],[11,"from","","",83,[[]]],[11,"into","","",83,[[]]],[11,"to_owned","","",83,[[]]],[11,"clone_into","","",83,[[]]],[11,"borrow","","",83,[[]]],[11,"borrow_mut","","",83,[[]]],[11,"try_from","","",83,[[],["result",4]]],[11,"try_into","","",83,[[],["result",4]]],[11,"type_id","","",83,[[],["typeid",3]]],[11,"span","","",84,[[],["span",3]]],[11,"from","","",84,[[]]],[11,"into","","",84,[[]]],[11,"to_owned","","",84,[[]]],[11,"clone_into","","",84,[[]]],[11,"borrow","","",84,[[]]],[11,"borrow_mut","","",84,[[]]],[11,"try_from","","",84,[[],["result",4]]],[11,"try_into","","",84,[[],["result",4]]],[11,"type_id","","",84,[[],["typeid",3]]],[11,"span","","",85,[[],["span",3]]],[11,"from","","",85,[[]]],[11,"into","","",85,[[]]],[11,"to_owned","","",85,[[]]],[11,"clone_into","","",85,[[]]],[11,"borrow","","",85,[[]]],[11,"borrow_mut","","",85,[[]]],[11,"try_from","","",85,[[],["result",4]]],[11,"try_into","","",85,[[],["result",4]]],[11,"type_id","","",85,[[],["typeid",3]]],[11,"span","","",86,[[],["span",3]]],[11,"from","","",86,[[]]],[11,"into","","",86,[[]]],[11,"to_owned","","",86,[[]]],[11,"clone_into","","",86,[[]]],[11,"borrow","","",86,[[]]],[11,"borrow_mut","","",86,[[]]],[11,"try_from","","",86,[[],["result",4]]],[11,"try_into","","",86,[[],["result",4]]],[11,"type_id","","",86,[[],["typeid",3]]],[11,"span","","",87,[[],["span",3]]],[11,"from","","",87,[[]]],[11,"into","","",87,[[]]],[11,"to_owned","","",87,[[]]],[11,"clone_into","","",87,[[]]],[11,"borrow","","",87,[[]]],[11,"borrow_mut","","",87,[[]]],[11,"try_from","","",87,[[],["result",4]]],[11,"try_into","","",87,[[],["result",4]]],[11,"type_id","","",87,[[],["typeid",3]]],[11,"span","","",88,[[],["span",3]]],[11,"from","","",88,[[]]],[11,"into","","",88,[[]]],[11,"to_owned","","",88,[[]]],[11,"clone_into","","",88,[[]]],[11,"borrow","","",88,[[]]],[11,"borrow_mut","","",88,[[]]],[11,"try_from","","",88,[[],["result",4]]],[11,"try_into","","",88,[[],["result",4]]],[11,"type_id","","",88,[[],["typeid",3]]],[11,"span","","",89,[[],["span",3]]],[11,"from","","",89,[[]]],[11,"into","","",89,[[]]],[11,"to_owned","","",89,[[]]],[11,"clone_into","","",89,[[]]],[11,"borrow","","",89,[[]]],[11,"borrow_mut","","",89,[[]]],[11,"try_from","","",89,[[],["result",4]]],[11,"try_into","","",89,[[],["result",4]]],[11,"type_id","","",89,[[],["typeid",3]]],[11,"span","","",90,[[],["span",3]]],[11,"from","","",90,[[]]],[11,"into","","",90,[[]]],[11,"to_owned","","",90,[[]]],[11,"clone_into","","",90,[[]]],[11,"borrow","","",90,[[]]],[11,"borrow_mut","","",90,[[]]],[11,"try_from","","",90,[[],["result",4]]],[11,"try_into","","",90,[[],["result",4]]],[11,"type_id","","",90,[[],["typeid",3]]],[11,"span","","",91,[[],["span",3]]],[11,"from","","",91,[[]]],[11,"into","","",91,[[]]],[11,"to_owned","","",91,[[]]],[11,"clone_into","","",91,[[]]],[11,"borrow","","",91,[[]]],[11,"borrow_mut","","",91,[[]]],[11,"try_from","","",91,[[],["result",4]]],[11,"try_into","","",91,[[],["result",4]]],[11,"type_id","","",91,[[],["typeid",3]]],[11,"span","","",92,[[],["span",3]]],[11,"from","","",92,[[]]],[11,"into","","",92,[[]]],[11,"to_owned","","",92,[[]]],[11,"clone_into","","",92,[[]]],[11,"borrow","","",92,[[]]],[11,"borrow_mut","","",92,[[]]],[11,"try_from","","",92,[[],["result",4]]],[11,"try_into","","",92,[[],["result",4]]],[11,"type_id","","",92,[[],["typeid",3]]],[11,"span","","",93,[[],["span",3]]],[11,"from","","",93,[[]]],[11,"into","","",93,[[]]],[11,"to_owned","","",93,[[]]],[11,"clone_into","","",93,[[]]],[11,"borrow","","",93,[[]]],[11,"borrow_mut","","",93,[[]]],[11,"try_from","","",93,[[],["result",4]]],[11,"try_into","","",93,[[],["result",4]]],[11,"type_id","","",93,[[],["typeid",3]]],[11,"span","","",94,[[],["span",3]]],[11,"from","","",94,[[]]],[11,"into","","",94,[[]]],[11,"to_owned","","",94,[[]]],[11,"clone_into","","",94,[[]]],[11,"borrow","","",94,[[]]],[11,"borrow_mut","","",94,[[]]],[11,"try_from","","",94,[[],["result",4]]],[11,"try_into","","",94,[[],["result",4]]],[11,"type_id","","",94,[[],["typeid",3]]],[11,"span","","",95,[[],["span",3]]],[11,"from","","",95,[[]]],[11,"into","","",95,[[]]],[11,"to_owned","","",95,[[]]],[11,"clone_into","","",95,[[]]],[11,"borrow","","",95,[[]]],[11,"borrow_mut","","",95,[[]]],[11,"try_from","","",95,[[],["result",4]]],[11,"try_into","","",95,[[],["result",4]]],[11,"type_id","","",95,[[],["typeid",3]]],[11,"span","","",96,[[],["span",3]]],[11,"from","","",96,[[]]],[11,"into","","",96,[[]]],[11,"to_owned","","",96,[[]]],[11,"clone_into","","",96,[[]]],[11,"borrow","","",96,[[]]],[11,"borrow_mut","","",96,[[]]],[11,"try_from","","",96,[[],["result",4]]],[11,"try_into","","",96,[[],["result",4]]],[11,"type_id","","",96,[[],["typeid",3]]],[11,"span","","",97,[[],["span",3]]],[11,"from","","",97,[[]]],[11,"into","","",97,[[]]],[11,"to_owned","","",97,[[]]],[11,"clone_into","","",97,[[]]],[11,"borrow","","",97,[[]]],[11,"borrow_mut","","",97,[[]]],[11,"try_from","","",97,[[],["result",4]]],[11,"try_into","","",97,[[],["result",4]]],[11,"type_id","","",97,[[],["typeid",3]]],[11,"span","","",98,[[],["span",3]]],[11,"from","","",98,[[]]],[11,"into","","",98,[[]]],[11,"to_owned","","",98,[[]]],[11,"clone_into","","",98,[[]]],[11,"borrow","","",98,[[]]],[11,"borrow_mut","","",98,[[]]],[11,"try_from","","",98,[[],["result",4]]],[11,"try_into","","",98,[[],["result",4]]],[11,"type_id","","",98,[[],["typeid",3]]],[11,"from","","",99,[[]]],[11,"into","","",99,[[]]],[11,"to_owned","","",99,[[]]],[11,"clone_into","","",99,[[]]],[11,"borrow","","",99,[[]]],[11,"borrow_mut","","",99,[[]]],[11,"try_from","","",99,[[],["result",4]]],[11,"try_into","","",99,[[],["result",4]]],[11,"type_id","","",99,[[],["typeid",3]]],[11,"from","","",100,[[]]],[11,"into","","",100,[[]]],[11,"to_owned","","",100,[[]]],[11,"clone_into","","",100,[[]]],[11,"borrow","","",100,[[]]],[11,"borrow_mut","","",100,[[]]],[11,"try_from","","",100,[[],["result",4]]],[11,"try_into","","",100,[[],["result",4]]],[11,"type_id","","",100,[[],["typeid",3]]],[11,"from","","",101,[[]]],[11,"into","","",101,[[]]],[11,"to_owned","","",101,[[]]],[11,"clone_into","","",101,[[]]],[11,"borrow","","",101,[[]]],[11,"borrow_mut","","",101,[[]]],[11,"try_from","","",101,[[],["result",4]]],[11,"try_into","","",101,[[],["result",4]]],[11,"type_id","","",101,[[],["typeid",3]]],[11,"from","","",102,[[]]],[11,"into","","",102,[[]]],[11,"to_owned","","",102,[[]]],[11,"clone_into","","",102,[[]]],[11,"borrow","","",102,[[]]],[11,"borrow_mut","","",102,[[]]],[11,"try_from","","",102,[[],["result",4]]],[11,"try_into","","",102,[[],["result",4]]],[11,"type_id","","",102,[[],["typeid",3]]],[11,"span","syn","",117,[[],["span",3]]],[11,"from","","",117,[[]]],[11,"into","","",117,[[]]],[11,"to_owned","","",117,[[]]],[11,"clone_into","","",117,[[]]],[11,"borrow","","",117,[[]]],[11,"borrow_mut","","",117,[[]]],[11,"try_from","","",117,[[],["result",4]]],[11,"try_into","","",117,[[],["result",4]]],[11,"type_id","","",117,[[],["typeid",3]]],[11,"from","","",116,[[]]],[11,"into","","",116,[[]]],[11,"to_owned","","",116,[[]]],[11,"clone_into","","",116,[[]]],[11,"borrow","","",116,[[]]],[11,"borrow_mut","","",116,[[]]],[11,"try_from","","",116,[[],["result",4]]],[11,"try_into","","",116,[[],["result",4]]],[11,"type_id","","",116,[[],["typeid",3]]],[11,"span","","",118,[[],["span",3]]],[11,"from","","",118,[[]]],[11,"into","","",118,[[]]],[11,"to_owned","","",118,[[]]],[11,"clone_into","","",118,[[]]],[11,"borrow","","",118,[[]]],[11,"borrow_mut","","",118,[[]]],[11,"try_from","","",118,[[],["result",4]]],[11,"try_into","","",118,[[],["result",4]]],[11,"type_id","","",118,[[],["typeid",3]]],[11,"span","","",119,[[],["span",3]]],[11,"from","","",119,[[]]],[11,"into","","",119,[[]]],[11,"to_owned","","",119,[[]]],[11,"clone_into","","",119,[[]]],[11,"borrow","","",119,[[]]],[11,"borrow_mut","","",119,[[]]],[11,"try_from","","",119,[[],["result",4]]],[11,"try_into","","",119,[[],["result",4]]],[11,"type_id","","",119,[[],["typeid",3]]],[11,"span","","",120,[[],["span",3]]],[11,"from","","",120,[[]]],[11,"into","","",120,[[]]],[11,"to_owned","","",120,[[]]],[11,"clone_into","","",120,[[]]],[11,"borrow","","",120,[[]]],[11,"borrow_mut","","",120,[[]]],[11,"try_from","","",120,[[],["result",4]]],[11,"try_into","","",120,[[],["result",4]]],[11,"type_id","","",120,[[],["typeid",3]]],[11,"span","","",121,[[],["span",3]]],[11,"from","","",121,[[]]],[11,"into","","",121,[[]]],[11,"to_owned","","",121,[[]]],[11,"clone_into","","",121,[[]]],[11,"borrow","","",121,[[]]],[11,"borrow_mut","","",121,[[]]],[11,"try_from","","",121,[[],["result",4]]],[11,"try_into","","",121,[[],["result",4]]],[11,"type_id","","",121,[[],["typeid",3]]],[11,"span","","",126,[[],["span",3]]],[11,"from","","",126,[[]]],[11,"into","","",126,[[]]],[11,"to_owned","","",126,[[]]],[11,"clone_into","","",126,[[]]],[11,"borrow","","",126,[[]]],[11,"borrow_mut","","",126,[[]]],[11,"try_from","","",126,[[],["result",4]]],[11,"try_into","","",126,[[],["result",4]]],[11,"type_id","","",126,[[],["typeid",3]]],[11,"span","","",123,[[],["span",3]]],[11,"from","","",123,[[]]],[11,"into","","",123,[[]]],[11,"to_owned","","",123,[[]]],[11,"clone_into","","",123,[[]]],[11,"borrow","","",123,[[]]],[11,"borrow_mut","","",123,[[]]],[11,"try_from","","",123,[[],["result",4]]],[11,"try_into","","",123,[[],["result",4]]],[11,"type_id","","",123,[[],["typeid",3]]],[11,"span","","",124,[[],["span",3]]],[11,"from","","",124,[[]]],[11,"into","","",124,[[]]],[11,"to_owned","","",124,[[]]],[11,"clone_into","","",124,[[]]],[11,"borrow","","",124,[[]]],[11,"borrow_mut","","",124,[[]]],[11,"try_from","","",124,[[],["result",4]]],[11,"try_into","","",124,[[],["result",4]]],[11,"type_id","","",124,[[],["typeid",3]]],[11,"span","","",125,[[],["span",3]]],[11,"from","","",125,[[]]],[11,"into","","",125,[[]]],[11,"to_owned","","",125,[[]]],[11,"clone_into","","",125,[[]]],[11,"borrow","","",125,[[]]],[11,"borrow_mut","","",125,[[]]],[11,"try_from","","",125,[[],["result",4]]],[11,"try_into","","",125,[[],["result",4]]],[11,"type_id","","",125,[[],["typeid",3]]],[11,"span","","",122,[[],["span",3]]],[11,"from","","",122,[[]]],[11,"into","","",122,[[]]],[11,"to_owned","","",122,[[]]],[11,"clone_into","","",122,[[]]],[11,"borrow","","",122,[[]]],[11,"borrow_mut","","",122,[[]]],[11,"try_from","","",122,[[],["result",4]]],[11,"try_into","","",122,[[],["result",4]]],[11,"type_id","","",122,[[],["typeid",3]]],[11,"span","","",130,[[],["span",3]]],[11,"from","","",130,[[]]],[11,"into","","",130,[[]]],[11,"to_owned","","",130,[[]]],[11,"clone_into","","",130,[[]]],[11,"borrow","","",130,[[]]],[11,"borrow_mut","","",130,[[]]],[11,"try_from","","",130,[[],["result",4]]],[11,"try_into","","",130,[[],["result",4]]],[11,"type_id","","",130,[[],["typeid",3]]],[11,"span","","",128,[[],["span",3]]],[11,"from","","",128,[[]]],[11,"into","","",128,[[]]],[11,"to_owned","","",128,[[]]],[11,"clone_into","","",128,[[]]],[11,"borrow","","",128,[[]]],[11,"borrow_mut","","",128,[[]]],[11,"try_from","","",128,[[],["result",4]]],[11,"try_into","","",128,[[],["result",4]]],[11,"type_id","","",128,[[],["typeid",3]]],[11,"span","","",127,[[],["span",3]]],[11,"from","","",127,[[]]],[11,"into","","",127,[[]]],[11,"to_owned","","",127,[[]]],[11,"clone_into","","",127,[[]]],[11,"borrow","","",127,[[]]],[11,"borrow_mut","","",127,[[]]],[11,"try_from","","",127,[[],["result",4]]],[11,"try_into","","",127,[[],["result",4]]],[11,"type_id","","",127,[[],["typeid",3]]],[11,"span","","",129,[[],["span",3]]],[11,"from","","",129,[[]]],[11,"into","","",129,[[]]],[11,"to_owned","","",129,[[]]],[11,"clone_into","","",129,[[]]],[11,"borrow","","",129,[[]]],[11,"borrow_mut","","",129,[[]]],[11,"try_from","","",129,[[],["result",4]]],[11,"try_into","","",129,[[],["result",4]]],[11,"type_id","","",129,[[],["typeid",3]]],[11,"span","","",131,[[],["span",3]]],[11,"from","","",131,[[]]],[11,"into","","",131,[[]]],[11,"to_owned","","",131,[[]]],[11,"clone_into","","",131,[[]]],[11,"borrow","","",131,[[]]],[11,"borrow_mut","","",131,[[]]],[11,"try_from","","",131,[[],["result",4]]],[11,"try_into","","",131,[[],["result",4]]],[11,"type_id","","",131,[[],["typeid",3]]],[11,"span","","",199,[[],["span",3]]],[11,"from","","",199,[[]]],[11,"into","","",199,[[]]],[11,"borrow","","",199,[[]]],[11,"borrow_mut","","",199,[[]]],[11,"try_from","","",199,[[],["result",4]]],[11,"try_into","","",199,[[],["result",4]]],[11,"type_id","","",199,[[],["typeid",3]]],[11,"span","","",200,[[],["span",3]]],[11,"from","","",200,[[]]],[11,"into","","",200,[[]]],[11,"borrow","","",200,[[]]],[11,"borrow_mut","","",200,[[]]],[11,"try_from","","",200,[[],["result",4]]],[11,"try_into","","",200,[[],["result",4]]],[11,"type_id","","",200,[[],["typeid",3]]],[11,"span","","",201,[[],["span",3]]],[11,"from","","",201,[[]]],[11,"into","","",201,[[]]],[11,"borrow","","",201,[[]]],[11,"borrow_mut","","",201,[[]]],[11,"try_from","","",201,[[],["result",4]]],[11,"try_into","","",201,[[],["result",4]]],[11,"type_id","","",201,[[],["typeid",3]]],[11,"span","","",202,[[],["span",3]]],[11,"from","","",202,[[]]],[11,"into","","",202,[[]]],[11,"borrow","","",202,[[]]],[11,"borrow_mut","","",202,[[]]],[11,"try_from","","",202,[[],["result",4]]],[11,"try_into","","",202,[[],["result",4]]],[11,"type_id","","",202,[[],["typeid",3]]],[11,"span","","",203,[[],["span",3]]],[11,"from","","",203,[[]]],[11,"into","","",203,[[]]],[11,"borrow","","",203,[[]]],[11,"borrow_mut","","",203,[[]]],[11,"try_from","","",203,[[],["result",4]]],[11,"try_into","","",203,[[],["result",4]]],[11,"type_id","","",203,[[],["typeid",3]]],[11,"span","","",132,[[],["span",3]]],[11,"from","","",132,[[]]],[11,"into","","",132,[[]]],[11,"to_owned","","",132,[[]]],[11,"clone_into","","",132,[[]]],[11,"borrow","","",132,[[]]],[11,"borrow_mut","","",132,[[]]],[11,"try_from","","",132,[[],["result",4]]],[11,"try_into","","",132,[[],["result",4]]],[11,"type_id","","",132,[[],["typeid",3]]],[11,"span","","",204,[[],["span",3]]],[11,"from","","",204,[[]]],[11,"into","","",204,[[]]],[11,"borrow","","",204,[[]]],[11,"borrow_mut","","",204,[[]]],[11,"try_from","","",204,[[],["result",4]]],[11,"try_into","","",204,[[],["result",4]]],[11,"type_id","","",204,[[],["typeid",3]]],[11,"span","","",205,[[],["span",3]]],[11,"from","","",205,[[]]],[11,"into","","",205,[[]]],[11,"borrow","","",205,[[]]],[11,"borrow_mut","","",205,[[]]],[11,"try_from","","",205,[[],["result",4]]],[11,"try_into","","",205,[[],["result",4]]],[11,"type_id","","",205,[[],["typeid",3]]],[11,"span","","",206,[[],["span",3]]],[11,"from","","",206,[[]]],[11,"into","","",206,[[]]],[11,"borrow","","",206,[[]]],[11,"borrow_mut","","",206,[[]]],[11,"try_from","","",206,[[],["result",4]]],[11,"try_into","","",206,[[],["result",4]]],[11,"type_id","","",206,[[],["typeid",3]]],[11,"span","","",133,[[],["span",3]]],[11,"from","","",133,[[]]],[11,"into","","",133,[[]]],[11,"to_owned","","",133,[[]]],[11,"clone_into","","",133,[[]]],[11,"borrow","","",133,[[]]],[11,"borrow_mut","","",133,[[]]],[11,"try_from","","",133,[[],["result",4]]],[11,"try_into","","",133,[[],["result",4]]],[11,"type_id","","",133,[[],["typeid",3]]],[11,"span","","",134,[[],["span",3]]],[11,"from","","",134,[[]]],[11,"into","","",134,[[]]],[11,"to_owned","","",134,[[]]],[11,"clone_into","","",134,[[]]],[11,"borrow","","",134,[[]]],[11,"borrow_mut","","",134,[[]]],[11,"try_from","","",134,[[],["result",4]]],[11,"try_into","","",134,[[],["result",4]]],[11,"type_id","","",134,[[],["typeid",3]]],[11,"span","","",207,[[],["span",3]]],[11,"from","","",207,[[]]],[11,"into","","",207,[[]]],[11,"borrow","","",207,[[]]],[11,"borrow_mut","","",207,[[]]],[11,"try_from","","",207,[[],["result",4]]],[11,"try_into","","",207,[[],["result",4]]],[11,"type_id","","",207,[[],["typeid",3]]],[11,"span","","",208,[[],["span",3]]],[11,"from","","",208,[[]]],[11,"into","","",208,[[]]],[11,"borrow","","",208,[[]]],[11,"borrow_mut","","",208,[[]]],[11,"try_from","","",208,[[],["result",4]]],[11,"try_into","","",208,[[],["result",4]]],[11,"type_id","","",208,[[],["typeid",3]]],[11,"span","","",135,[[],["span",3]]],[11,"from","","",135,[[]]],[11,"into","","",135,[[]]],[11,"to_owned","","",135,[[]]],[11,"clone_into","","",135,[[]]],[11,"borrow","","",135,[[]]],[11,"borrow_mut","","",135,[[]]],[11,"try_from","","",135,[[],["result",4]]],[11,"try_into","","",135,[[],["result",4]]],[11,"type_id","","",135,[[],["typeid",3]]],[11,"span","","",209,[[],["span",3]]],[11,"from","","",209,[[]]],[11,"into","","",209,[[]]],[11,"borrow","","",209,[[]]],[11,"borrow_mut","","",209,[[]]],[11,"try_from","","",209,[[],["result",4]]],[11,"try_into","","",209,[[],["result",4]]],[11,"type_id","","",209,[[],["typeid",3]]],[11,"span","","",210,[[],["span",3]]],[11,"from","","",210,[[]]],[11,"into","","",210,[[]]],[11,"borrow","","",210,[[]]],[11,"borrow_mut","","",210,[[]]],[11,"try_from","","",210,[[],["result",4]]],[11,"try_into","","",210,[[],["result",4]]],[11,"type_id","","",210,[[],["typeid",3]]],[11,"span","","",211,[[],["span",3]]],[11,"from","","",211,[[]]],[11,"into","","",211,[[]]],[11,"borrow","","",211,[[]]],[11,"borrow_mut","","",211,[[]]],[11,"try_from","","",211,[[],["result",4]]],[11,"try_into","","",211,[[],["result",4]]],[11,"type_id","","",211,[[],["typeid",3]]],[11,"span","","",136,[[],["span",3]]],[11,"from","","",136,[[]]],[11,"into","","",136,[[]]],[11,"to_owned","","",136,[[]]],[11,"clone_into","","",136,[[]]],[11,"borrow","","",136,[[]]],[11,"borrow_mut","","",136,[[]]],[11,"try_from","","",136,[[],["result",4]]],[11,"try_into","","",136,[[],["result",4]]],[11,"type_id","","",136,[[],["typeid",3]]],[11,"span","","",212,[[],["span",3]]],[11,"from","","",212,[[]]],[11,"into","","",212,[[]]],[11,"borrow","","",212,[[]]],[11,"borrow_mut","","",212,[[]]],[11,"try_from","","",212,[[],["result",4]]],[11,"try_into","","",212,[[],["result",4]]],[11,"type_id","","",212,[[],["typeid",3]]],[11,"span","","",137,[[],["span",3]]],[11,"from","","",137,[[]]],[11,"into","","",137,[[]]],[11,"to_owned","","",137,[[]]],[11,"clone_into","","",137,[[]]],[11,"borrow","","",137,[[]]],[11,"borrow_mut","","",137,[[]]],[11,"try_from","","",137,[[],["result",4]]],[11,"try_into","","",137,[[],["result",4]]],[11,"type_id","","",137,[[],["typeid",3]]],[11,"span","","",213,[[],["span",3]]],[11,"from","","",213,[[]]],[11,"into","","",213,[[]]],[11,"borrow","","",213,[[]]],[11,"borrow_mut","","",213,[[]]],[11,"try_from","","",213,[[],["result",4]]],[11,"try_into","","",213,[[],["result",4]]],[11,"type_id","","",213,[[],["typeid",3]]],[11,"span","","",214,[[],["span",3]]],[11,"from","","",214,[[]]],[11,"into","","",214,[[]]],[11,"borrow","","",214,[[]]],[11,"borrow_mut","","",214,[[]]],[11,"try_from","","",214,[[],["result",4]]],[11,"try_into","","",214,[[],["result",4]]],[11,"type_id","","",214,[[],["typeid",3]]],[11,"span","","",215,[[],["span",3]]],[11,"from","","",215,[[]]],[11,"into","","",215,[[]]],[11,"borrow","","",215,[[]]],[11,"borrow_mut","","",215,[[]]],[11,"try_from","","",215,[[],["result",4]]],[11,"try_into","","",215,[[],["result",4]]],[11,"type_id","","",215,[[],["typeid",3]]],[11,"span","","",216,[[],["span",3]]],[11,"from","","",216,[[]]],[11,"into","","",216,[[]]],[11,"borrow","","",216,[[]]],[11,"borrow_mut","","",216,[[]]],[11,"try_from","","",216,[[],["result",4]]],[11,"try_into","","",216,[[],["result",4]]],[11,"type_id","","",216,[[],["typeid",3]]],[11,"span","","",138,[[],["span",3]]],[11,"from","","",138,[[]]],[11,"into","","",138,[[]]],[11,"to_owned","","",138,[[]]],[11,"clone_into","","",138,[[]]],[11,"borrow","","",138,[[]]],[11,"borrow_mut","","",138,[[]]],[11,"try_from","","",138,[[],["result",4]]],[11,"try_into","","",138,[[],["result",4]]],[11,"type_id","","",138,[[],["typeid",3]]],[11,"span","","",139,[[],["span",3]]],[11,"from","","",139,[[]]],[11,"into","","",139,[[]]],[11,"to_owned","","",139,[[]]],[11,"clone_into","","",139,[[]]],[11,"borrow","","",139,[[]]],[11,"borrow_mut","","",139,[[]]],[11,"try_from","","",139,[[],["result",4]]],[11,"try_into","","",139,[[],["result",4]]],[11,"type_id","","",139,[[],["typeid",3]]],[11,"span","","",217,[[],["span",3]]],[11,"from","","",217,[[]]],[11,"into","","",217,[[]]],[11,"borrow","","",217,[[]]],[11,"borrow_mut","","",217,[[]]],[11,"try_from","","",217,[[],["result",4]]],[11,"try_into","","",217,[[],["result",4]]],[11,"type_id","","",217,[[],["typeid",3]]],[11,"span","","",218,[[],["span",3]]],[11,"from","","",218,[[]]],[11,"into","","",218,[[]]],[11,"borrow","","",218,[[]]],[11,"borrow_mut","","",218,[[]]],[11,"try_from","","",218,[[],["result",4]]],[11,"try_into","","",218,[[],["result",4]]],[11,"type_id","","",218,[[],["typeid",3]]],[11,"span","","",219,[[],["span",3]]],[11,"from","","",219,[[]]],[11,"into","","",219,[[]]],[11,"borrow","","",219,[[]]],[11,"borrow_mut","","",219,[[]]],[11,"try_from","","",219,[[],["result",4]]],[11,"try_into","","",219,[[],["result",4]]],[11,"type_id","","",219,[[],["typeid",3]]],[11,"span","","",220,[[],["span",3]]],[11,"from","","",220,[[]]],[11,"into","","",220,[[]]],[11,"borrow","","",220,[[]]],[11,"borrow_mut","","",220,[[]]],[11,"try_from","","",220,[[],["result",4]]],[11,"try_into","","",220,[[],["result",4]]],[11,"type_id","","",220,[[],["typeid",3]]],[11,"span","","",221,[[],["span",3]]],[11,"from","","",221,[[]]],[11,"into","","",221,[[]]],[11,"borrow","","",221,[[]]],[11,"borrow_mut","","",221,[[]]],[11,"try_from","","",221,[[],["result",4]]],[11,"try_into","","",221,[[],["result",4]]],[11,"type_id","","",221,[[],["typeid",3]]],[11,"span","","",222,[[],["span",3]]],[11,"from","","",222,[[]]],[11,"into","","",222,[[]]],[11,"borrow","","",222,[[]]],[11,"borrow_mut","","",222,[[]]],[11,"try_from","","",222,[[],["result",4]]],[11,"try_into","","",222,[[],["result",4]]],[11,"type_id","","",222,[[],["typeid",3]]],[11,"span","","",223,[[],["span",3]]],[11,"from","","",223,[[]]],[11,"into","","",223,[[]]],[11,"borrow","","",223,[[]]],[11,"borrow_mut","","",223,[[]]],[11,"try_from","","",223,[[],["result",4]]],[11,"try_into","","",223,[[],["result",4]]],[11,"type_id","","",223,[[],["typeid",3]]],[11,"span","","",224,[[],["span",3]]],[11,"from","","",224,[[]]],[11,"into","","",224,[[]]],[11,"borrow","","",224,[[]]],[11,"borrow_mut","","",224,[[]]],[11,"try_from","","",224,[[],["result",4]]],[11,"try_into","","",224,[[],["result",4]]],[11,"type_id","","",224,[[],["typeid",3]]],[11,"span","","",225,[[],["span",3]]],[11,"from","","",225,[[]]],[11,"into","","",225,[[]]],[11,"borrow","","",225,[[]]],[11,"borrow_mut","","",225,[[]]],[11,"try_from","","",225,[[],["result",4]]],[11,"try_into","","",225,[[],["result",4]]],[11,"type_id","","",225,[[],["typeid",3]]],[11,"span","","",140,[[],["span",3]]],[11,"from","","",140,[[]]],[11,"into","","",140,[[]]],[11,"to_owned","","",140,[[]]],[11,"clone_into","","",140,[[]]],[11,"borrow","","",140,[[]]],[11,"borrow_mut","","",140,[[]]],[11,"try_from","","",140,[[],["result",4]]],[11,"try_into","","",140,[[],["result",4]]],[11,"type_id","","",140,[[],["typeid",3]]],[11,"span","","",226,[[],["span",3]]],[11,"from","","",226,[[]]],[11,"into","","",226,[[]]],[11,"borrow","","",226,[[]]],[11,"borrow_mut","","",226,[[]]],[11,"try_from","","",226,[[],["result",4]]],[11,"try_into","","",226,[[],["result",4]]],[11,"type_id","","",226,[[],["typeid",3]]],[11,"span","","",227,[[],["span",3]]],[11,"from","","",227,[[]]],[11,"into","","",227,[[]]],[11,"borrow","","",227,[[]]],[11,"borrow_mut","","",227,[[]]],[11,"try_from","","",227,[[],["result",4]]],[11,"try_into","","",227,[[],["result",4]]],[11,"type_id","","",227,[[],["typeid",3]]],[11,"span","","",228,[[],["span",3]]],[11,"from","","",228,[[]]],[11,"into","","",228,[[]]],[11,"borrow","","",228,[[]]],[11,"borrow_mut","","",228,[[]]],[11,"try_from","","",228,[[],["result",4]]],[11,"try_into","","",228,[[],["result",4]]],[11,"type_id","","",228,[[],["typeid",3]]],[11,"span","","",142,[[],["span",3]]],[11,"from","","",142,[[]]],[11,"into","","",142,[[]]],[11,"to_owned","","",142,[[]]],[11,"clone_into","","",142,[[]]],[11,"borrow","","",142,[[]]],[11,"borrow_mut","","",142,[[]]],[11,"try_from","","",142,[[],["result",4]]],[11,"try_into","","",142,[[],["result",4]]],[11,"type_id","","",142,[[],["typeid",3]]],[11,"span","","",141,[[],["span",3]]],[11,"from","","",141,[[]]],[11,"into","","",141,[[]]],[11,"to_owned","","",141,[[]]],[11,"clone_into","","",141,[[]]],[11,"borrow","","",141,[[]]],[11,"borrow_mut","","",141,[[]]],[11,"try_from","","",141,[[],["result",4]]],[11,"try_into","","",141,[[],["result",4]]],[11,"type_id","","",141,[[],["typeid",3]]],[11,"span","","",146,[[],["span",3]]],[11,"from","","",146,[[]]],[11,"into","","",146,[[]]],[11,"to_owned","","",146,[[]]],[11,"clone_into","","",146,[[]]],[11,"borrow","","",146,[[]]],[11,"borrow_mut","","",146,[[]]],[11,"try_from","","",146,[[],["result",4]]],[11,"try_into","","",146,[[],["result",4]]],[11,"type_id","","",146,[[],["typeid",3]]],[11,"span","","",145,[[],["span",3]]],[11,"from","","",145,[[]]],[11,"into","","",145,[[]]],[11,"to_owned","","",145,[[]]],[11,"clone_into","","",145,[[]]],[11,"borrow","","",145,[[]]],[11,"borrow_mut","","",145,[[]]],[11,"try_from","","",145,[[],["result",4]]],[11,"try_into","","",145,[[],["result",4]]],[11,"type_id","","",145,[[],["typeid",3]]],[11,"span","","",153,[[],["span",3]]],[11,"from","","",153,[[]]],[11,"into","","",153,[[]]],[11,"to_owned","","",153,[[]]],[11,"clone_into","","",153,[[]]],[11,"borrow","","",153,[[]]],[11,"borrow_mut","","",153,[[]]],[11,"try_from","","",153,[[],["result",4]]],[11,"try_into","","",153,[[],["result",4]]],[11,"type_id","","",153,[[],["typeid",3]]],[11,"span","","",147,[[],["span",3]]],[11,"from","","",147,[[]]],[11,"into","","",147,[[]]],[11,"to_owned","","",147,[[]]],[11,"clone_into","","",147,[[]]],[11,"borrow","","",147,[[]]],[11,"borrow_mut","","",147,[[]]],[11,"try_from","","",147,[[],["result",4]]],[11,"try_into","","",147,[[],["result",4]]],[11,"type_id","","",147,[[],["typeid",3]]],[11,"span","","",144,[[],["span",3]]],[11,"from","","",144,[[]]],[11,"into","","",144,[[]]],[11,"to_owned","","",144,[[]]],[11,"clone_into","","",144,[[]]],[11,"borrow","","",144,[[]]],[11,"borrow_mut","","",144,[[]]],[11,"try_from","","",144,[[],["result",4]]],[11,"try_into","","",144,[[],["result",4]]],[11,"type_id","","",144,[[],["typeid",3]]],[11,"span","","",229,[[],["span",3]]],[11,"from","","",229,[[]]],[11,"into","","",229,[[]]],[11,"to_owned","","",229,[[]]],[11,"clone_into","","",229,[[]]],[11,"borrow","","",229,[[]]],[11,"borrow_mut","","",229,[[]]],[11,"try_from","","",229,[[],["result",4]]],[11,"try_into","","",229,[[],["result",4]]],[11,"type_id","","",229,[[],["typeid",3]]],[11,"span","","",230,[[],["span",3]]],[11,"from","","",230,[[]]],[11,"into","","",230,[[]]],[11,"to_owned","","",230,[[]]],[11,"clone_into","","",230,[[]]],[11,"borrow","","",230,[[]]],[11,"borrow_mut","","",230,[[]]],[11,"try_from","","",230,[[],["result",4]]],[11,"try_into","","",230,[[],["result",4]]],[11,"type_id","","",230,[[],["typeid",3]]],[11,"span","","",231,[[],["span",3]]],[11,"from","","",231,[[]]],[11,"into","","",231,[[]]],[11,"to_owned","","",231,[[]]],[11,"clone_into","","",231,[[]]],[11,"borrow","","",231,[[]]],[11,"borrow_mut","","",231,[[]]],[11,"try_from","","",231,[[],["result",4]]],[11,"try_into","","",231,[[],["result",4]]],[11,"type_id","","",231,[[],["typeid",3]]],[11,"span","","",143,[[],["span",3]]],[11,"from","","",143,[[]]],[11,"into","","",143,[[]]],[11,"to_owned","","",143,[[]]],[11,"clone_into","","",143,[[]]],[11,"borrow","","",143,[[]]],[11,"borrow_mut","","",143,[[]]],[11,"try_from","","",143,[[],["result",4]]],[11,"try_into","","",143,[[],["result",4]]],[11,"type_id","","",143,[[],["typeid",3]]],[11,"span","","",154,[[],["span",3]]],[11,"from","","",154,[[]]],[11,"into","","",154,[[]]],[11,"to_owned","","",154,[[]]],[11,"clone_into","","",154,[[]]],[11,"borrow","","",154,[[]]],[11,"borrow_mut","","",154,[[]]],[11,"try_from","","",154,[[],["result",4]]],[11,"try_into","","",154,[[],["result",4]]],[11,"type_id","","",154,[[],["typeid",3]]],[11,"span","","",151,[[],["span",3]]],[11,"from","","",151,[[]]],[11,"into","","",151,[[]]],[11,"to_owned","","",151,[[]]],[11,"clone_into","","",151,[[]]],[11,"borrow","","",151,[[]]],[11,"borrow_mut","","",151,[[]]],[11,"try_from","","",151,[[],["result",4]]],[11,"try_into","","",151,[[],["result",4]]],[11,"type_id","","",151,[[],["typeid",3]]],[11,"span","","",152,[[],["span",3]]],[11,"from","","",152,[[]]],[11,"into","","",152,[[]]],[11,"to_owned","","",152,[[]]],[11,"clone_into","","",152,[[]]],[11,"borrow","","",152,[[]]],[11,"borrow_mut","","",152,[[]]],[11,"try_from","","",152,[[],["result",4]]],[11,"try_into","","",152,[[],["result",4]]],[11,"type_id","","",152,[[],["typeid",3]]],[11,"span","","",155,[[],["span",3]]],[11,"from","","",155,[[]]],[11,"into","","",155,[[]]],[11,"to_owned","","",155,[[]]],[11,"clone_into","","",155,[[]]],[11,"borrow","","",155,[[]]],[11,"borrow_mut","","",155,[[]]],[11,"try_from","","",155,[[],["result",4]]],[11,"try_into","","",155,[[],["result",4]]],[11,"type_id","","",155,[[],["typeid",3]]],[11,"span","","",156,[[],["span",3]]],[11,"from","","",156,[[]]],[11,"into","","",156,[[]]],[11,"to_owned","","",156,[[]]],[11,"clone_into","","",156,[[]]],[11,"borrow","","",156,[[]]],[11,"borrow_mut","","",156,[[]]],[11,"try_from","","",156,[[],["result",4]]],[11,"try_into","","",156,[[],["result",4]]],[11,"type_id","","",156,[[],["typeid",3]]],[11,"span","","",150,[[],["span",3]]],[11,"from","","",150,[[]]],[11,"into","","",150,[[]]],[11,"to_owned","","",150,[[]]],[11,"clone_into","","",150,[[]]],[11,"borrow","","",150,[[]]],[11,"borrow_mut","","",150,[[]]],[11,"try_from","","",150,[[],["result",4]]],[11,"try_into","","",150,[[],["result",4]]],[11,"type_id","","",150,[[],["typeid",3]]],[11,"span","","",149,[[],["span",3]]],[11,"from","","",149,[[]]],[11,"into","","",149,[[]]],[11,"to_owned","","",149,[[]]],[11,"clone_into","","",149,[[]]],[11,"borrow","","",149,[[]]],[11,"borrow_mut","","",149,[[]]],[11,"try_from","","",149,[[],["result",4]]],[11,"try_into","","",149,[[],["result",4]]],[11,"type_id","","",149,[[],["typeid",3]]],[11,"span","","",148,[[],["span",3]]],[11,"from","","",148,[[]]],[11,"into","","",148,[[]]],[11,"to_owned","","",148,[[]]],[11,"clone_into","","",148,[[]]],[11,"borrow","","",148,[[]]],[11,"borrow_mut","","",148,[[]]],[11,"try_from","","",148,[[],["result",4]]],[11,"try_into","","",148,[[],["result",4]]],[11,"type_id","","",148,[[],["typeid",3]]],[11,"span","","",157,[[],["span",3]]],[11,"from","","",157,[[]]],[11,"into","","",157,[[]]],[11,"to_owned","","",157,[[]]],[11,"clone_into","","",157,[[]]],[11,"to_string","","",157,[[],["string",3]]],[11,"borrow","","",157,[[]]],[11,"borrow_mut","","",157,[[]]],[11,"try_from","","",157,[[],["result",4]]],[11,"try_into","","",157,[[],["result",4]]],[11,"type_id","","",157,[[],["typeid",3]]],[11,"span","","",158,[[],["span",3]]],[11,"from","","",158,[[]]],[11,"into","","",158,[[]]],[11,"to_owned","","",158,[[]]],[11,"clone_into","","",158,[[]]],[11,"borrow","","",158,[[]]],[11,"borrow_mut","","",158,[[]]],[11,"try_from","","",158,[[],["result",4]]],[11,"try_into","","",158,[[],["result",4]]],[11,"type_id","","",158,[[],["typeid",3]]],[11,"span","","",232,[[],["span",3]]],[11,"from","","",232,[[]]],[11,"into","","",232,[[]]],[11,"to_owned","","",232,[[]]],[11,"clone_into","","",232,[[]]],[11,"borrow","","",232,[[]]],[11,"borrow_mut","","",232,[[]]],[11,"try_from","","",232,[[],["result",4]]],[11,"try_into","","",232,[[],["result",4]]],[11,"type_id","","",232,[[],["typeid",3]]],[11,"span","","",233,[[],["span",3]]],[11,"from","","",233,[[]]],[11,"into","","",233,[[]]],[11,"to_owned","","",233,[[]]],[11,"clone_into","","",233,[[]]],[11,"borrow","","",233,[[]]],[11,"borrow_mut","","",233,[[]]],[11,"try_from","","",233,[[],["result",4]]],[11,"try_into","","",233,[[],["result",4]]],[11,"type_id","","",233,[[],["typeid",3]]],[11,"span","","",234,[[],["span",3]]],[11,"from","","",234,[[]]],[11,"into","","",234,[[]]],[11,"to_owned","","",234,[[]]],[11,"clone_into","","",234,[[]]],[11,"borrow","","",234,[[]]],[11,"borrow_mut","","",234,[[]]],[11,"try_from","","",234,[[],["result",4]]],[11,"try_into","","",234,[[],["result",4]]],[11,"type_id","","",234,[[],["typeid",3]]],[11,"span","","",235,[[],["span",3]]],[11,"from","","",235,[[]]],[11,"into","","",235,[[]]],[11,"to_owned","","",235,[[]]],[11,"clone_into","","",235,[[]]],[11,"borrow","","",235,[[]]],[11,"borrow_mut","","",235,[[]]],[11,"try_from","","",235,[[],["result",4]]],[11,"try_into","","",235,[[],["result",4]]],[11,"type_id","","",235,[[],["typeid",3]]],[11,"span","","",236,[[],["span",3]]],[11,"from","","",236,[[]]],[11,"into","","",236,[[]]],[11,"to_owned","","",236,[[]]],[11,"clone_into","","",236,[[]]],[11,"to_string","","",236,[[],["string",3]]],[11,"borrow","","",236,[[]]],[11,"borrow_mut","","",236,[[]]],[11,"try_from","","",236,[[],["result",4]]],[11,"try_into","","",236,[[],["result",4]]],[11,"type_id","","",236,[[],["typeid",3]]],[11,"span","","",237,[[],["span",3]]],[11,"from","","",237,[[]]],[11,"into","","",237,[[]]],[11,"to_owned","","",237,[[]]],[11,"clone_into","","",237,[[]]],[11,"to_string","","",237,[[],["string",3]]],[11,"borrow","","",237,[[]]],[11,"borrow_mut","","",237,[[]]],[11,"try_from","","",237,[[],["result",4]]],[11,"try_into","","",237,[[],["result",4]]],[11,"type_id","","",237,[[],["typeid",3]]],[11,"span","","",159,[[],["span",3]]],[11,"from","","",159,[[]]],[11,"into","","",159,[[]]],[11,"to_owned","","",159,[[]]],[11,"clone_into","","",159,[[]]],[11,"borrow","","",159,[[]]],[11,"borrow_mut","","",159,[[]]],[11,"try_from","","",159,[[],["result",4]]],[11,"try_into","","",159,[[],["result",4]]],[11,"type_id","","",159,[[],["typeid",3]]],[11,"from","","",160,[[]]],[11,"into","","",160,[[]]],[11,"borrow","","",160,[[]]],[11,"borrow_mut","","",160,[[]]],[11,"try_from","","",160,[[],["result",4]]],[11,"try_into","","",160,[[],["result",4]]],[11,"type_id","","",160,[[],["typeid",3]]],[11,"span","","",161,[[],["span",3]]],[11,"from","","",161,[[]]],[11,"into","","",161,[[]]],[11,"to_owned","","",161,[[]]],[11,"clone_into","","",161,[[]]],[11,"borrow","","",161,[[]]],[11,"borrow_mut","","",161,[[]]],[11,"try_from","","",161,[[],["result",4]]],[11,"try_into","","",161,[[],["result",4]]],[11,"type_id","","",161,[[],["typeid",3]]],[11,"from","","",162,[[]]],[11,"into","","",162,[[]]],[11,"to_owned","","",162,[[]]],[11,"clone_into","","",162,[[]]],[11,"borrow","","",162,[[]]],[11,"borrow_mut","","",162,[[]]],[11,"try_from","","",162,[[],["result",4]]],[11,"try_into","","",162,[[],["result",4]]],[11,"type_id","","",162,[[],["typeid",3]]],[11,"span","","",167,[[],["span",3]]],[11,"from","","",167,[[]]],[11,"into","","",167,[[]]],[11,"to_owned","","",167,[[]]],[11,"clone_into","","",167,[[]]],[11,"borrow","","",167,[[]]],[11,"borrow_mut","","",167,[[]]],[11,"try_from","","",167,[[],["result",4]]],[11,"try_into","","",167,[[],["result",4]]],[11,"type_id","","",167,[[],["typeid",3]]],[11,"from","","",163,[[]]],[11,"into","","",163,[[]]],[11,"to_owned","","",163,[[]]],[11,"clone_into","","",163,[[]]],[11,"borrow","","",163,[[]]],[11,"borrow_mut","","",163,[[]]],[11,"try_from","","",163,[[],["result",4]]],[11,"try_into","","",163,[[],["result",4]]],[11,"type_id","","",163,[[],["typeid",3]]],[11,"from","","",165,[[]]],[11,"into","","",165,[[]]],[11,"to_owned","","",165,[[]]],[11,"clone_into","","",165,[[]]],[11,"borrow","","",165,[[]]],[11,"borrow_mut","","",165,[[]]],[11,"try_from","","",165,[[],["result",4]]],[11,"try_into","","",165,[[],["result",4]]],[11,"type_id","","",165,[[],["typeid",3]]],[11,"from","","",164,[[]]],[11,"into","","",164,[[]]],[11,"to_owned","","",164,[[]]],[11,"clone_into","","",164,[[]]],[11,"borrow","","",164,[[]]],[11,"borrow_mut","","",164,[[]]],[11,"try_from","","",164,[[],["result",4]]],[11,"try_into","","",164,[[],["result",4]]],[11,"type_id","","",164,[[],["typeid",3]]],[11,"from","","",166,[[]]],[11,"into","","",166,[[]]],[11,"to_owned","","",166,[[]]],[11,"clone_into","","",166,[[]]],[11,"borrow","","",166,[[]]],[11,"borrow_mut","","",166,[[]]],[11,"try_from","","",166,[[],["result",4]]],[11,"try_into","","",166,[[],["result",4]]],[11,"type_id","","",166,[[],["typeid",3]]],[11,"span","","",168,[[],["span",3]]],[11,"from","","",168,[[]]],[11,"into","","",168,[[]]],[11,"to_owned","","",168,[[]]],[11,"clone_into","","",168,[[]]],[11,"borrow","","",168,[[]]],[11,"borrow_mut","","",168,[[]]],[11,"try_from","","",168,[[],["result",4]]],[11,"try_into","","",168,[[],["result",4]]],[11,"type_id","","",168,[[],["typeid",3]]],[11,"span","","",169,[[],["span",3]]],[11,"from","","",169,[[]]],[11,"into","","",169,[[]]],[11,"to_owned","","",169,[[]]],[11,"clone_into","","",169,[[]]],[11,"borrow","","",169,[[]]],[11,"borrow_mut","","",169,[[]]],[11,"try_from","","",169,[[],["result",4]]],[11,"try_into","","",169,[[],["result",4]]],[11,"type_id","","",169,[[],["typeid",3]]],[11,"span","","",173,[[],["span",3]]],[11,"from","","",173,[[]]],[11,"into","","",173,[[]]],[11,"to_owned","","",173,[[]]],[11,"clone_into","","",173,[[]]],[11,"borrow","","",173,[[]]],[11,"borrow_mut","","",173,[[]]],[11,"try_from","","",173,[[],["result",4]]],[11,"try_into","","",173,[[],["result",4]]],[11,"type_id","","",173,[[],["typeid",3]]],[11,"span","","",174,[[],["span",3]]],[11,"from","","",174,[[]]],[11,"into","","",174,[[]]],[11,"to_owned","","",174,[[]]],[11,"clone_into","","",174,[[]]],[11,"borrow","","",174,[[]]],[11,"borrow_mut","","",174,[[]]],[11,"try_from","","",174,[[],["result",4]]],[11,"try_into","","",174,[[],["result",4]]],[11,"type_id","","",174,[[],["typeid",3]]],[11,"span","","",175,[[],["span",3]]],[11,"from","","",175,[[]]],[11,"into","","",175,[[]]],[11,"to_owned","","",175,[[]]],[11,"clone_into","","",175,[[]]],[11,"borrow","","",175,[[]]],[11,"borrow_mut","","",175,[[]]],[11,"try_from","","",175,[[],["result",4]]],[11,"try_into","","",175,[[],["result",4]]],[11,"type_id","","",175,[[],["typeid",3]]],[11,"span","","",176,[[],["span",3]]],[11,"from","","",176,[[]]],[11,"into","","",176,[[]]],[11,"to_owned","","",176,[[]]],[11,"clone_into","","",176,[[]]],[11,"borrow","","",176,[[]]],[11,"borrow_mut","","",176,[[]]],[11,"try_from","","",176,[[],["result",4]]],[11,"try_into","","",176,[[],["result",4]]],[11,"type_id","","",176,[[],["typeid",3]]],[11,"span","","",177,[[],["span",3]]],[11,"from","","",177,[[]]],[11,"into","","",177,[[]]],[11,"to_owned","","",177,[[]]],[11,"clone_into","","",177,[[]]],[11,"borrow","","",177,[[]]],[11,"borrow_mut","","",177,[[]]],[11,"try_from","","",177,[[],["result",4]]],[11,"try_into","","",177,[[],["result",4]]],[11,"type_id","","",177,[[],["typeid",3]]],[11,"span","","",178,[[],["span",3]]],[11,"from","","",178,[[]]],[11,"into","","",178,[[]]],[11,"to_owned","","",178,[[]]],[11,"clone_into","","",178,[[]]],[11,"borrow","","",178,[[]]],[11,"borrow_mut","","",178,[[]]],[11,"try_from","","",178,[[],["result",4]]],[11,"try_into","","",178,[[],["result",4]]],[11,"type_id","","",178,[[],["typeid",3]]],[11,"span","","",179,[[],["span",3]]],[11,"from","","",179,[[]]],[11,"into","","",179,[[]]],[11,"to_owned","","",179,[[]]],[11,"clone_into","","",179,[[]]],[11,"borrow","","",179,[[]]],[11,"borrow_mut","","",179,[[]]],[11,"try_from","","",179,[[],["result",4]]],[11,"try_into","","",179,[[],["result",4]]],[11,"type_id","","",179,[[],["typeid",3]]],[11,"span","","",180,[[],["span",3]]],[11,"from","","",180,[[]]],[11,"into","","",180,[[]]],[11,"to_owned","","",180,[[]]],[11,"clone_into","","",180,[[]]],[11,"borrow","","",180,[[]]],[11,"borrow_mut","","",180,[[]]],[11,"try_from","","",180,[[],["result",4]]],[11,"try_into","","",180,[[],["result",4]]],[11,"type_id","","",180,[[],["typeid",3]]],[11,"span","","",181,[[],["span",3]]],[11,"from","","",181,[[]]],[11,"into","","",181,[[]]],[11,"to_owned","","",181,[[]]],[11,"clone_into","","",181,[[]]],[11,"borrow","","",181,[[]]],[11,"borrow_mut","","",181,[[]]],[11,"try_from","","",181,[[],["result",4]]],[11,"try_into","","",181,[[],["result",4]]],[11,"type_id","","",181,[[],["typeid",3]]],[11,"span","","",182,[[],["span",3]]],[11,"from","","",182,[[]]],[11,"into","","",182,[[]]],[11,"to_owned","","",182,[[]]],[11,"clone_into","","",182,[[]]],[11,"borrow","","",182,[[]]],[11,"borrow_mut","","",182,[[]]],[11,"try_from","","",182,[[],["result",4]]],[11,"try_into","","",182,[[],["result",4]]],[11,"type_id","","",182,[[],["typeid",3]]],[11,"span","","",183,[[],["span",3]]],[11,"from","","",183,[[]]],[11,"into","","",183,[[]]],[11,"to_owned","","",183,[[]]],[11,"clone_into","","",183,[[]]],[11,"borrow","","",183,[[]]],[11,"borrow_mut","","",183,[[]]],[11,"try_from","","",183,[[],["result",4]]],[11,"try_into","","",183,[[],["result",4]]],[11,"type_id","","",183,[[],["typeid",3]]],[11,"span","","",184,[[],["span",3]]],[11,"from","","",184,[[]]],[11,"into","","",184,[[]]],[11,"to_owned","","",184,[[]]],[11,"clone_into","","",184,[[]]],[11,"borrow","","",184,[[]]],[11,"borrow_mut","","",184,[[]]],[11,"try_from","","",184,[[],["result",4]]],[11,"try_into","","",184,[[],["result",4]]],[11,"type_id","","",184,[[],["typeid",3]]],[11,"span","","",185,[[],["span",3]]],[11,"from","","",185,[[]]],[11,"into","","",185,[[]]],[11,"to_owned","","",185,[[]]],[11,"clone_into","","",185,[[]]],[11,"borrow","","",185,[[]]],[11,"borrow_mut","","",185,[[]]],[11,"try_from","","",185,[[],["result",4]]],[11,"try_into","","",185,[[],["result",4]]],[11,"type_id","","",185,[[],["typeid",3]]],[11,"span","","",186,[[],["span",3]]],[11,"from","","",186,[[]]],[11,"into","","",186,[[]]],[11,"to_owned","","",186,[[]]],[11,"clone_into","","",186,[[]]],[11,"borrow","","",186,[[]]],[11,"borrow_mut","","",186,[[]]],[11,"try_from","","",186,[[],["result",4]]],[11,"try_into","","",186,[[],["result",4]]],[11,"type_id","","",186,[[],["typeid",3]]],[11,"span","","",187,[[],["span",3]]],[11,"from","","",187,[[]]],[11,"into","","",187,[[]]],[11,"to_owned","","",187,[[]]],[11,"clone_into","","",187,[[]]],[11,"borrow","","",187,[[]]],[11,"borrow_mut","","",187,[[]]],[11,"try_from","","",187,[[],["result",4]]],[11,"try_into","","",187,[[],["result",4]]],[11,"type_id","","",187,[[],["typeid",3]]],[11,"span","","",170,[[],["span",3]]],[11,"from","","",170,[[]]],[11,"into","","",170,[[]]],[11,"to_owned","","",170,[[]]],[11,"clone_into","","",170,[[]]],[11,"borrow","","",170,[[]]],[11,"borrow_mut","","",170,[[]]],[11,"try_from","","",170,[[],["result",4]]],[11,"try_into","","",170,[[],["result",4]]],[11,"type_id","","",170,[[],["typeid",3]]],[11,"span","","",171,[[],["span",3]]],[11,"from","","",171,[[]]],[11,"into","","",171,[[]]],[11,"to_owned","","",171,[[]]],[11,"clone_into","","",171,[[]]],[11,"borrow","","",171,[[]]],[11,"borrow_mut","","",171,[[]]],[11,"try_from","","",171,[[],["result",4]]],[11,"try_into","","",171,[[],["result",4]]],[11,"type_id","","",171,[[],["typeid",3]]],[11,"span","","",188,[[],["span",3]]],[11,"from","","",188,[[]]],[11,"into","","",188,[[]]],[11,"to_owned","","",188,[[]]],[11,"clone_into","","",188,[[]]],[11,"borrow","","",188,[[]]],[11,"borrow_mut","","",188,[[]]],[11,"try_from","","",188,[[],["result",4]]],[11,"try_into","","",188,[[],["result",4]]],[11,"type_id","","",188,[[],["typeid",3]]],[11,"span","","",172,[[],["span",3]]],[11,"from","","",172,[[]]],[11,"into","","",172,[[]]],[11,"to_owned","","",172,[[]]],[11,"clone_into","","",172,[[]]],[11,"borrow","","",172,[[]]],[11,"borrow_mut","","",172,[[]]],[11,"try_from","","",172,[[],["result",4]]],[11,"try_into","","",172,[[],["result",4]]],[11,"type_id","","",172,[[],["typeid",3]]],[11,"span","","",194,[[],["span",3]]],[11,"from","","",194,[[]]],[11,"into","","",194,[[]]],[11,"to_owned","","",194,[[]]],[11,"clone_into","","",194,[[]]],[11,"borrow","","",194,[[]]],[11,"borrow_mut","","",194,[[]]],[11,"try_from","","",194,[[],["result",4]]],[11,"try_into","","",194,[[],["result",4]]],[11,"type_id","","",194,[[],["typeid",3]]],[11,"span","","",196,[[],["span",3]]],[11,"from","","",196,[[]]],[11,"into","","",196,[[]]],[11,"to_owned","","",196,[[]]],[11,"clone_into","","",196,[[]]],[11,"borrow","","",196,[[]]],[11,"borrow_mut","","",196,[[]]],[11,"try_from","","",196,[[],["result",4]]],[11,"try_into","","",196,[[],["result",4]]],[11,"type_id","","",196,[[],["typeid",3]]],[11,"span","","",195,[[],["span",3]]],[11,"from","","",195,[[]]],[11,"into","","",195,[[]]],[11,"to_owned","","",195,[[]]],[11,"clone_into","","",195,[[]]],[11,"borrow","","",195,[[]]],[11,"borrow_mut","","",195,[[]]],[11,"try_from","","",195,[[],["result",4]]],[11,"try_into","","",195,[[],["result",4]]],[11,"type_id","","",195,[[],["typeid",3]]],[11,"span","","",192,[[],["span",3]]],[11,"from","","",192,[[]]],[11,"into","","",192,[[]]],[11,"to_owned","","",192,[[]]],[11,"clone_into","","",192,[[]]],[11,"borrow","","",192,[[]]],[11,"borrow_mut","","",192,[[]]],[11,"try_from","","",192,[[],["result",4]]],[11,"try_into","","",192,[[],["result",4]]],[11,"type_id","","",192,[[],["typeid",3]]],[11,"span","","",189,[[],["span",3]]],[11,"from","","",189,[[]]],[11,"into","","",189,[[]]],[11,"to_owned","","",189,[[]]],[11,"clone_into","","",189,[[]]],[11,"borrow","","",189,[[]]],[11,"borrow_mut","","",189,[[]]],[11,"try_from","","",189,[[],["result",4]]],[11,"try_into","","",189,[[],["result",4]]],[11,"type_id","","",189,[[],["typeid",3]]],[11,"span","","",190,[[],["span",3]]],[11,"from","","",190,[[]]],[11,"into","","",190,[[]]],[11,"to_owned","","",190,[[]]],[11,"clone_into","","",190,[[]]],[11,"borrow","","",190,[[]]],[11,"borrow_mut","","",190,[[]]],[11,"try_from","","",190,[[],["result",4]]],[11,"try_into","","",190,[[],["result",4]]],[11,"type_id","","",190,[[],["typeid",3]]],[11,"span","","",191,[[],["span",3]]],[11,"from","","",191,[[]]],[11,"into","","",191,[[]]],[11,"to_owned","","",191,[[]]],[11,"clone_into","","",191,[[]]],[11,"borrow","","",191,[[]]],[11,"borrow_mut","","",191,[[]]],[11,"try_from","","",191,[[],["result",4]]],[11,"try_into","","",191,[[],["result",4]]],[11,"type_id","","",191,[[],["typeid",3]]],[11,"span","","",193,[[],["span",3]]],[11,"from","","",193,[[]]],[11,"into","","",193,[[]]],[11,"to_owned","","",193,[[]]],[11,"clone_into","","",193,[[]]],[11,"borrow","","",193,[[]]],[11,"borrow_mut","","",193,[[]]],[11,"try_from","","",193,[[],["result",4]]],[11,"try_into","","",193,[[],["result",4]]],[11,"type_id","","",193,[[],["typeid",3]]],[11,"from","","",197,[[]]],[11,"into","","",197,[[]]],[11,"to_owned","","",197,[[]]],[11,"clone_into","","",197,[[]]],[11,"borrow","","",197,[[]]],[11,"borrow_mut","","",197,[[]]],[11,"try_from","","",197,[[],["result",4]]],[11,"try_into","","",197,[[],["result",4]]],[11,"type_id","","",197,[[],["typeid",3]]],[11,"from","syn::buffer","",103,[[]]],[11,"into","","",103,[[]]],[11,"borrow","","",103,[[]]],[11,"borrow_mut","","",103,[[]]],[11,"try_from","","",103,[[],["result",4]]],[11,"try_into","","",103,[[],["result",4]]],[11,"type_id","","",103,[[],["typeid",3]]],[11,"from","","",104,[[]]],[11,"into","","",104,[[]]],[11,"to_owned","","",104,[[]]],[11,"clone_into","","",104,[[]]],[11,"borrow","","",104,[[]]],[11,"borrow_mut","","",104,[[]]],[11,"try_from","","",104,[[],["result",4]]],[11,"try_into","","",104,[[],["result",4]]],[11,"type_id","","",104,[[],["typeid",3]]],[11,"span","syn::punctuated","",106,[[],["span",3]]],[11,"from","","",106,[[]]],[11,"into","","",106,[[]]],[11,"to_owned","","",106,[[]]],[11,"clone_into","","",106,[[]]],[11,"borrow","","",106,[[]]],[11,"borrow_mut","","",106,[[]]],[11,"try_from","","",106,[[],["result",4]]],[11,"try_into","","",106,[[],["result",4]]],[11,"type_id","","",106,[[],["typeid",3]]],[11,"from","","",238,[[]]],[11,"into","","",238,[[]]],[11,"into_iter","","",238,[[]]],[11,"to_owned","","",238,[[]]],[11,"clone_into","","",238,[[]]],[11,"borrow","","",238,[[]]],[11,"borrow_mut","","",238,[[]]],[11,"try_from","","",238,[[],["result",4]]],[11,"try_into","","",238,[[],["result",4]]],[11,"type_id","","",238,[[],["typeid",3]]],[11,"from","","",239,[[]]],[11,"into","","",239,[[]]],[11,"into_iter","","",239,[[]]],[11,"borrow","","",239,[[]]],[11,"borrow_mut","","",239,[[]]],[11,"try_from","","",239,[[],["result",4]]],[11,"try_into","","",239,[[],["result",4]]],[11,"type_id","","",239,[[],["typeid",3]]],[11,"from","","",240,[[]]],[11,"into","","",240,[[]]],[11,"into_iter","","",240,[[]]],[11,"to_owned","","",240,[[]]],[11,"clone_into","","",240,[[]]],[11,"borrow","","",240,[[]]],[11,"borrow_mut","","",240,[[]]],[11,"try_from","","",240,[[],["result",4]]],[11,"try_into","","",240,[[],["result",4]]],[11,"type_id","","",240,[[],["typeid",3]]],[11,"from","","",241,[[]]],[11,"into","","",241,[[]]],[11,"into_iter","","",241,[[]]],[11,"to_owned","","",241,[[]]],[11,"clone_into","","",241,[[]]],[11,"borrow","","",241,[[]]],[11,"borrow_mut","","",241,[[]]],[11,"try_from","","",241,[[],["result",4]]],[11,"try_into","","",241,[[],["result",4]]],[11,"type_id","","",241,[[],["typeid",3]]],[11,"from","","",242,[[]]],[11,"into","","",242,[[]]],[11,"into_iter","","",242,[[]]],[11,"to_owned","","",242,[[]]],[11,"clone_into","","",242,[[]]],[11,"borrow","","",242,[[]]],[11,"borrow_mut","","",242,[[]]],[11,"try_from","","",242,[[],["result",4]]],[11,"try_into","","",242,[[],["result",4]]],[11,"type_id","","",242,[[],["typeid",3]]],[11,"from","","",243,[[]]],[11,"into","","",243,[[]]],[11,"into_iter","","",243,[[]]],[11,"borrow","","",243,[[]]],[11,"borrow_mut","","",243,[[]]],[11,"try_from","","",243,[[],["result",4]]],[11,"try_into","","",243,[[],["result",4]]],[11,"type_id","","",243,[[],["typeid",3]]],[11,"span","","",107,[[],["span",3]]],[11,"from","","",107,[[]]],[11,"into","","",107,[[]]],[11,"to_owned","","",107,[[]]],[11,"clone_into","","",107,[[]]],[11,"borrow","","",107,[[]]],[11,"borrow_mut","","",107,[[]]],[11,"try_from","","",107,[[],["result",4]]],[11,"try_into","","",107,[[],["result",4]]],[11,"type_id","","",107,[[],["typeid",3]]],[11,"from","syn::parse","",244,[[]]],[11,"into","","",244,[[]]],[11,"borrow","","",244,[[]]],[11,"borrow_mut","","",244,[[]]],[11,"try_from","","",244,[[],["result",4]]],[11,"try_into","","",244,[[],["result",4]]],[11,"type_id","","",244,[[],["typeid",3]]],[11,"from","","",115,[[]]],[11,"into","","",115,[[]]],[11,"to_owned","","",115,[[]]],[11,"clone_into","","",115,[[]]],[11,"to_string","","",115,[[],["string",3]]],[11,"borrow","","",115,[[]]],[11,"borrow_mut","","",115,[[]]],[11,"try_from","","",115,[[],["result",4]]],[11,"try_into","","",115,[[],["result",4]]],[11,"type_id","","",115,[[],["typeid",3]]],[11,"from","","",113,[[]]],[11,"into","","",113,[[]]],[11,"to_string","","",113,[[],["string",3]]],[11,"borrow","","",113,[[]]],[11,"borrow_mut","","",113,[[]]],[11,"try_from","","",113,[[],["result",4]]],[11,"try_into","","",113,[[],["result",4]]],[11,"type_id","","",113,[[],["typeid",3]]],[11,"from","","",112,[[]]],[11,"into","","",112,[[]]],[11,"to_owned","","",112,[[]]],[11,"clone_into","","",112,[[]]],[11,"borrow","","",112,[[]]],[11,"borrow_mut","","",112,[[]]],[11,"try_from","","",112,[[],["result",4]]],[11,"try_into","","",112,[[],["result",4]]],[11,"type_id","","",112,[[],["typeid",3]]],[11,"from","","",245,[[]]],[11,"into","","",245,[[]]],[11,"borrow","","",245,[[]]],[11,"borrow_mut","","",245,[[]]],[11,"try_from","","",245,[[],["result",4]]],[11,"try_into","","",245,[[],["result",4]]],[11,"type_id","","",245,[[],["typeid",3]]],[11,"fmt","syn","",198,[[["formatter",3]],[["result",4],["error",3]]]],[11,"partial_cmp","","",198,[[["ident",3]],[["ordering",4],["option",4]]]],[11,"hash","","",198,[[]]],[11,"clone","","",198,[[],["ident",3]]],[11,"cmp","","",198,[[["ident",3]],["ordering",4]]],[11,"eq","","",198,[[]]],[11,"eq","","",198,[[["ident",3]]]],[11,"fmt","","",198,[[["formatter",3]],[["result",4],["error",3]]]],[11,"span","","",198,[[],[["option",4],["span",3]]]],[11,"fmt","","",198,[[["formatter",3]],[["result",4],["error",3]]]],[11,"to_tokens","","",198,[[["tokenstream",3]]]],[11,"peek","","",157,[[["cursor",3]]]],[11,"display","","",157,[[]]],[11,"peek","","",158,[[["cursor",3]]]],[11,"display","","",158,[[]]],[11,"peek","","",232,[[["cursor",3]]]],[11,"display","","",232,[[]]],[11,"peek","","",233,[[["cursor",3]]]],[11,"display","","",233,[[]]],[11,"peek","","",234,[[["cursor",3]]]],[11,"display","","",234,[[]]],[11,"peek","","",235,[[["cursor",3]]]],[11,"display","","",235,[[]]],[11,"peek","","",236,[[["cursor",3]]]],[11,"display","","",236,[[]]],[11,"peek","","",237,[[["cursor",3]]]],[11,"display","","",237,[[]]],[11,"peek","","",159,[[["cursor",3]]]],[11,"display","","",159,[[]]],[11,"peek","syn::token","",0,[[["cursor",3]]]],[11,"display","","",0,[[]]],[11,"peek","","",101,[[["cursor",3]]]],[11,"display","","",101,[[]]],[11,"peek","","",99,[[["cursor",3]]]],[11,"display","","",99,[[]]],[11,"peek","","",100,[[["cursor",3]]]],[11,"display","","",100,[[]]],[11,"peek","","",102,[[["cursor",3]]]],[11,"display","","",102,[[]]],[11,"peek","","",1,[[["cursor",3]]]],[11,"display","","",1,[[]]],[11,"peek","","",2,[[["cursor",3]]]],[11,"display","","",2,[[]]],[11,"peek","","",3,[[["cursor",3]]]],[11,"display","","",3,[[]]],[11,"peek","","",4,[[["cursor",3]]]],[11,"display","","",4,[[]]],[11,"peek","","",5,[[["cursor",3]]]],[11,"display","","",5,[[]]],[11,"peek","","",6,[[["cursor",3]]]],[11,"display","","",6,[[]]],[11,"peek","","",7,[[["cursor",3]]]],[11,"display","","",7,[[]]],[11,"peek","","",8,[[["cursor",3]]]],[11,"display","","",8,[[]]],[11,"peek","","",9,[[["cursor",3]]]],[11,"display","","",9,[[]]],[11,"peek","","",10,[[["cursor",3]]]],[11,"display","","",10,[[]]],[11,"peek","","",11,[[["cursor",3]]]],[11,"display","","",11,[[]]],[11,"peek","","",12,[[["cursor",3]]]],[11,"display","","",12,[[]]],[11,"peek","","",13,[[["cursor",3]]]],[11,"display","","",13,[[]]],[11,"peek","","",14,[[["cursor",3]]]],[11,"display","","",14,[[]]],[11,"peek","","",15,[[["cursor",3]]]],[11,"display","","",15,[[]]],[11,"peek","","",16,[[["cursor",3]]]],[11,"display","","",16,[[]]],[11,"peek","","",17,[[["cursor",3]]]],[11,"display","","",17,[[]]],[11,"peek","","",18,[[["cursor",3]]]],[11,"display","","",18,[[]]],[11,"peek","","",19,[[["cursor",3]]]],[11,"display","","",19,[[]]],[11,"peek","","",20,[[["cursor",3]]]],[11,"display","","",20,[[]]],[11,"peek","","",21,[[["cursor",3]]]],[11,"display","","",21,[[]]],[11,"peek","","",22,[[["cursor",3]]]],[11,"display","","",22,[[]]],[11,"peek","","",23,[[["cursor",3]]]],[11,"display","","",23,[[]]],[11,"peek","","",24,[[["cursor",3]]]],[11,"display","","",24,[[]]],[11,"peek","","",25,[[["cursor",3]]]],[11,"display","","",25,[[]]],[11,"peek","","",26,[[["cursor",3]]]],[11,"display","","",26,[[]]],[11,"peek","","",27,[[["cursor",3]]]],[11,"display","","",27,[[]]],[11,"peek","","",28,[[["cursor",3]]]],[11,"display","","",28,[[]]],[11,"peek","","",29,[[["cursor",3]]]],[11,"display","","",29,[[]]],[11,"peek","","",30,[[["cursor",3]]]],[11,"display","","",30,[[]]],[11,"peek","","",31,[[["cursor",3]]]],[11,"display","","",31,[[]]],[11,"peek","","",32,[[["cursor",3]]]],[11,"display","","",32,[[]]],[11,"peek","","",33,[[["cursor",3]]]],[11,"display","","",33,[[]]],[11,"peek","","",34,[[["cursor",3]]]],[11,"display","","",34,[[]]],[11,"peek","","",35,[[["cursor",3]]]],[11,"display","","",35,[[]]],[11,"peek","","",36,[[["cursor",3]]]],[11,"display","","",36,[[]]],[11,"peek","","",37,[[["cursor",3]]]],[11,"display","","",37,[[]]],[11,"peek","","",38,[[["cursor",3]]]],[11,"display","","",38,[[]]],[11,"peek","","",39,[[["cursor",3]]]],[11,"display","","",39,[[]]],[11,"peek","","",40,[[["cursor",3]]]],[11,"display","","",40,[[]]],[11,"peek","","",41,[[["cursor",3]]]],[11,"display","","",41,[[]]],[11,"peek","","",42,[[["cursor",3]]]],[11,"display","","",42,[[]]],[11,"peek","","",43,[[["cursor",3]]]],[11,"display","","",43,[[]]],[11,"peek","","",44,[[["cursor",3]]]],[11,"display","","",44,[[]]],[11,"peek","","",45,[[["cursor",3]]]],[11,"display","","",45,[[]]],[11,"peek","","",46,[[["cursor",3]]]],[11,"display","","",46,[[]]],[11,"peek","","",47,[[["cursor",3]]]],[11,"display","","",47,[[]]],[11,"peek","","",48,[[["cursor",3]]]],[11,"display","","",48,[[]]],[11,"peek","","",49,[[["cursor",3]]]],[11,"display","","",49,[[]]],[11,"peek","","",50,[[["cursor",3]]]],[11,"display","","",50,[[]]],[11,"peek","","",51,[[["cursor",3]]]],[11,"display","","",51,[[]]],[11,"peek","","",52,[[["cursor",3]]]],[11,"display","","",52,[[]]],[11,"peek","","",53,[[["cursor",3]]]],[11,"display","","",53,[[]]],[11,"peek","","",54,[[["cursor",3]]]],[11,"display","","",54,[[]]],[11,"peek","","",55,[[["cursor",3]]]],[11,"display","","",55,[[]]],[11,"peek","","",56,[[["cursor",3]]]],[11,"display","","",56,[[]]],[11,"peek","","",57,[[["cursor",3]]]],[11,"display","","",57,[[]]],[11,"peek","","",58,[[["cursor",3]]]],[11,"display","","",58,[[]]],[11,"peek","","",59,[[["cursor",3]]]],[11,"display","","",59,[[]]],[11,"peek","","",60,[[["cursor",3]]]],[11,"display","","",60,[[]]],[11,"peek","","",61,[[["cursor",3]]]],[11,"display","","",61,[[]]],[11,"peek","","",62,[[["cursor",3]]]],[11,"display","","",62,[[]]],[11,"peek","","",63,[[["cursor",3]]]],[11,"display","","",63,[[]]],[11,"peek","","",64,[[["cursor",3]]]],[11,"display","","",64,[[]]],[11,"peek","","",65,[[["cursor",3]]]],[11,"display","","",65,[[]]],[11,"peek","","",66,[[["cursor",3]]]],[11,"display","","",66,[[]]],[11,"peek","","",67,[[["cursor",3]]]],[11,"display","","",67,[[]]],[11,"peek","","",68,[[["cursor",3]]]],[11,"display","","",68,[[]]],[11,"peek","","",69,[[["cursor",3]]]],[11,"display","","",69,[[]]],[11,"peek","","",70,[[["cursor",3]]]],[11,"display","","",70,[[]]],[11,"peek","","",71,[[["cursor",3]]]],[11,"display","","",71,[[]]],[11,"peek","","",72,[[["cursor",3]]]],[11,"display","","",72,[[]]],[11,"peek","","",73,[[["cursor",3]]]],[11,"display","","",73,[[]]],[11,"peek","","",74,[[["cursor",3]]]],[11,"display","","",74,[[]]],[11,"peek","","",75,[[["cursor",3]]]],[11,"display","","",75,[[]]],[11,"peek","","",76,[[["cursor",3]]]],[11,"display","","",76,[[]]],[11,"peek","","",77,[[["cursor",3]]]],[11,"display","","",77,[[]]],[11,"peek","","",78,[[["cursor",3]]]],[11,"display","","",78,[[]]],[11,"peek","","",79,[[["cursor",3]]]],[11,"display","","",79,[[]]],[11,"peek","","",80,[[["cursor",3]]]],[11,"display","","",80,[[]]],[11,"peek","","",81,[[["cursor",3]]]],[11,"display","","",81,[[]]],[11,"peek","","",82,[[["cursor",3]]]],[11,"display","","",82,[[]]],[11,"peek","","",83,[[["cursor",3]]]],[11,"display","","",83,[[]]],[11,"peek","","",84,[[["cursor",3]]]],[11,"display","","",84,[[]]],[11,"peek","","",85,[[["cursor",3]]]],[11,"display","","",85,[[]]],[11,"peek","","",86,[[["cursor",3]]]],[11,"display","","",86,[[]]],[11,"peek","","",87,[[["cursor",3]]]],[11,"display","","",87,[[]]],[11,"peek","","",88,[[["cursor",3]]]],[11,"display","","",88,[[]]],[11,"peek","","",89,[[["cursor",3]]]],[11,"display","","",89,[[]]],[11,"peek","","",90,[[["cursor",3]]]],[11,"display","","",90,[[]]],[11,"peek","","",91,[[["cursor",3]]]],[11,"display","","",91,[[]]],[11,"peek","","",92,[[["cursor",3]]]],[11,"display","","",92,[[]]],[11,"peek","","",93,[[["cursor",3]]]],[11,"display","","",93,[[]]],[11,"peek","","",94,[[["cursor",3]]]],[11,"display","","",94,[[]]],[11,"peek","","",95,[[["cursor",3]]]],[11,"display","","",95,[[]]],[11,"peek","","",96,[[["cursor",3]]]],[11,"display","","",96,[[]]],[11,"peek","","",97,[[["cursor",3]]]],[11,"display","","",97,[[]]],[11,"peek","","",98,[[["cursor",3]]]],[11,"display","","",98,[[]]],[11,"peek","syn","",198,[[["cursor",3]]]],[11,"display","","",198,[[]]],[11,"parse_any","","",198,[[["parsestream",6]],["result",6]]],[11,"unraw","","",198,[[],["ident",3]]],[11,"advance_to","syn::parse","",113,[[]]],[11,"parse","syn::token","",0,[[["parsestream",6]],["result",6]]],[11,"parse","","",1,[[["parsestream",6]],["result",6]]],[11,"parse","","",2,[[["parsestream",6]],["result",6]]],[11,"parse","","",3,[[["parsestream",6]],["result",6]]],[11,"parse","","",4,[[["parsestream",6]],["result",6]]],[11,"parse","","",5,[[["parsestream",6]],["result",6]]],[11,"parse","","",6,[[["parsestream",6]],["result",6]]],[11,"parse","","",7,[[["parsestream",6]],["result",6]]],[11,"parse","","",8,[[["parsestream",6]],["result",6]]],[11,"parse","","",9,[[["parsestream",6]],["result",6]]],[11,"parse","","",10,[[["parsestream",6]],["result",6]]],[11,"parse","","",11,[[["parsestream",6]],["result",6]]],[11,"parse","","",12,[[["parsestream",6]],["result",6]]],[11,"parse","","",13,[[["parsestream",6]],["result",6]]],[11,"parse","","",14,[[["parsestream",6]],["result",6]]],[11,"parse","","",15,[[["parsestream",6]],["result",6]]],[11,"parse","","",16,[[["parsestream",6]],["result",6]]],[11,"parse","","",17,[[["parsestream",6]],["result",6]]],[11,"parse","","",18,[[["parsestream",6]],["result",6]]],[11,"parse","","",19,[[["parsestream",6]],["result",6]]],[11,"parse","","",20,[[["parsestream",6]],["result",6]]],[11,"parse","","",21,[[["parsestream",6]],["result",6]]],[11,"parse","","",22,[[["parsestream",6]],["result",6]]],[11,"parse","","",23,[[["parsestream",6]],["result",6]]],[11,"parse","","",24,[[["parsestream",6]],["result",6]]],[11,"parse","","",25,[[["parsestream",6]],["result",6]]],[11,"parse","","",26,[[["parsestream",6]],["result",6]]],[11,"parse","","",27,[[["parsestream",6]],["result",6]]],[11,"parse","","",28,[[["parsestream",6]],["result",6]]],[11,"parse","","",29,[[["parsestream",6]],["result",6]]],[11,"parse","","",30,[[["parsestream",6]],["result",6]]],[11,"parse","","",31,[[["parsestream",6]],["result",6]]],[11,"parse","","",32,[[["parsestream",6]],["result",6]]],[11,"parse","","",33,[[["parsestream",6]],["result",6]]],[11,"parse","","",34,[[["parsestream",6]],["result",6]]],[11,"parse","","",35,[[["parsestream",6]],["result",6]]],[11,"parse","","",36,[[["parsestream",6]],["result",6]]],[11,"parse","","",37,[[["parsestream",6]],["result",6]]],[11,"parse","","",38,[[["parsestream",6]],["result",6]]],[11,"parse","","",39,[[["parsestream",6]],["result",6]]],[11,"parse","","",40,[[["parsestream",6]],["result",6]]],[11,"parse","","",41,[[["parsestream",6]],["result",6]]],[11,"parse","","",42,[[["parsestream",6]],["result",6]]],[11,"parse","","",43,[[["parsestream",6]],["result",6]]],[11,"parse","","",44,[[["parsestream",6]],["result",6]]],[11,"parse","","",45,[[["parsestream",6]],["result",6]]],[11,"parse","","",46,[[["parsestream",6]],["result",6]]],[11,"parse","","",47,[[["parsestream",6]],["result",6]]],[11,"parse","","",48,[[["parsestream",6]],["result",6]]],[11,"parse","","",49,[[["parsestream",6]],["result",6]]],[11,"parse","","",50,[[["parsestream",6]],["result",6]]],[11,"parse","","",51,[[["parsestream",6]],["result",6]]],[11,"parse","","",52,[[["parsestream",6]],["result",6]]],[11,"parse","","",53,[[["parsestream",6]],["result",6]]],[11,"parse","","",54,[[["parsestream",6]],["result",6]]],[11,"parse","","",55,[[["parsestream",6]],["result",6]]],[11,"parse","","",56,[[["parsestream",6]],["result",6]]],[11,"parse","","",57,[[["parsestream",6]],["result",6]]],[11,"parse","","",58,[[["parsestream",6]],["result",6]]],[11,"parse","","",59,[[["parsestream",6]],["result",6]]],[11,"parse","","",60,[[["parsestream",6]],["result",6]]],[11,"parse","","",61,[[["parsestream",6]],["result",6]]],[11,"parse","","",62,[[["parsestream",6]],["result",6]]],[11,"parse","","",63,[[["parsestream",6]],["result",6]]],[11,"parse","","",64,[[["parsestream",6]],["result",6]]],[11,"parse","","",65,[[["parsestream",6]],["result",6]]],[11,"parse","","",66,[[["parsestream",6]],["result",6]]],[11,"parse","","",67,[[["parsestream",6]],["result",6]]],[11,"parse","","",68,[[["parsestream",6]],["result",6]]],[11,"parse","","",69,[[["parsestream",6]],["result",6]]],[11,"parse","","",70,[[["parsestream",6]],["result",6]]],[11,"parse","","",71,[[["parsestream",6]],["result",6]]],[11,"parse","","",72,[[["parsestream",6]],["result",6]]],[11,"parse","","",73,[[["parsestream",6]],["result",6]]],[11,"parse","","",74,[[["parsestream",6]],["result",6]]],[11,"parse","","",75,[[["parsestream",6]],["result",6]]],[11,"parse","","",76,[[["parsestream",6]],["result",6]]],[11,"parse","","",77,[[["parsestream",6]],["result",6]]],[11,"parse","","",78,[[["parsestream",6]],["result",6]]],[11,"parse","","",79,[[["parsestream",6]],["result",6]]],[11,"parse","","",80,[[["parsestream",6]],["result",6]]],[11,"parse","","",81,[[["parsestream",6]],["result",6]]],[11,"parse","","",82,[[["parsestream",6]],["result",6]]],[11,"parse","","",83,[[["parsestream",6]],["result",6]]],[11,"parse","","",84,[[["parsestream",6]],["result",6]]],[11,"parse","","",85,[[["parsestream",6]],["result",6]]],[11,"parse","","",86,[[["parsestream",6]],["result",6]]],[11,"parse","","",87,[[["parsestream",6]],["result",6]]],[11,"parse","","",88,[[["parsestream",6]],["result",6]]],[11,"parse","","",89,[[["parsestream",6]],["result",6]]],[11,"parse","","",90,[[["parsestream",6]],["result",6]]],[11,"parse","","",91,[[["parsestream",6]],["result",6]]],[11,"parse","","",92,[[["parsestream",6]],["result",6]]],[11,"parse","","",93,[[["parsestream",6]],["result",6]]],[11,"parse","","",94,[[["parsestream",6]],["result",6]]],[11,"parse","","",95,[[["parsestream",6]],["result",6]]],[11,"parse","","",96,[[["parsestream",6]],["result",6]]],[11,"parse","","",97,[[["parsestream",6]],["result",6]]],[11,"parse","","",98,[[["parsestream",6]],["result",6]]],[11,"parse","syn","",198,[[["parsestream",6]],["result",6]]],[11,"parse","","",118,[[["parsestream",6]],["result",6]]],[11,"parse","","",119,[[["parsestream",6]],["result",6]]],[11,"parse","","",120,[[["parsestream",6]],["result",6]]],[11,"parse","","",121,[[["parsestream",6]],["result",6]]],[11,"parse","","",126,[[["parsestream",6]],["result",6]]],[11,"parse","","",124,[[["parsestream",6]],["result",6]]],[11,"parse","","",125,[[["parsestream",6]],["result",6]]],[11,"parse","","",130,[[["parsestream",6]],["result",6]]],[11,"parse","","",131,[[["parsestream",6]],["result",6]]],[11,"parse","","",137,[[["parsestream",6]],["result",6]]],[11,"parse","","",139,[[["parsestream",6]],["result",6]]],[11,"parse","","",142,[[["parsestream",6]],["result",6]]],[11,"parse","","",141,[[["parsestream",6]],["result",6]]],[11,"parse","","",146,[[["parsestream",6]],["result",6]]],[11,"parse","","",145,[[["parsestream",6]],["result",6]]],[11,"parse","","",147,[[["parsestream",6]],["result",6]]],[11,"parse","","",143,[[["parsestream",6]],["result",6]]],[11,"parse","","",153,[[["parsestream",6]],["result",6]]],[11,"parse","","",154,[[["parsestream",6]],["result",6]]],[11,"parse","","",151,[[["parsestream",6]],["result",6]]],[11,"parse","","",152,[[["parsestream",6]],["result",6]]],[11,"parse","","",144,[[["parsestream",6]],["result",6]]],[11,"parse","","",155,[[["parsestream",6]],["result",6]]],[11,"parse","","",156,[[["parsestream",6]],["result",6]]],[11,"parse","","",157,[[["parsestream",6]],["result",6]]],[11,"parse","","",158,[[["parsestream",6]],["result",6]]],[11,"parse","","",232,[[["parsestream",6]],["result",6]]],[11,"parse","","",233,[[["parsestream",6]],["result",6]]],[11,"parse","","",234,[[["parsestream",6]],["result",6]]],[11,"parse","","",235,[[["parsestream",6]],["result",6]]],[11,"parse","","",236,[[["parsestream",6]],["result",6]]],[11,"parse","","",237,[[["parsestream",6]],["result",6]]],[11,"parse","","",159,[[["parsestream",6]],["result",6]]],[11,"parse","","",161,[[["parsestream",6]],["result",6]]],[11,"parse","","",167,[[["parsestream",6]],["result",6]]],[11,"parse","","",168,[[["parsestream",6]],["result",6]]],[11,"parse","","",169,[[["parsestream",6]],["result",6]]],[11,"parse","","",173,[[["parsestream",6]],["result",6]]],[11,"parse","","",185,[[["parsestream",6]],["result",6]]],[11,"parse","","",174,[[["parsestream",6]],["result",6]]],[11,"parse","","",183,[[["parsestream",6]],["result",6]]],[11,"parse","","",184,[[["parsestream",6]],["result",6]]],[11,"parse","","",175,[[["parsestream",6]],["result",6]]],[11,"parse","","",180,[[["parsestream",6]],["result",6]]],[11,"parse","","",178,[[["parsestream",6]],["result",6]]],[11,"parse","","",187,[[["parsestream",6]],["result",6]]],[11,"parse","","",179,[[["parsestream",6]],["result",6]]],[11,"parse","","",182,[[["parsestream",6]],["result",6]]],[11,"parse","","",172,[[["parsestream",6]],["result",6]]],[11,"parse","","",186,[[["parsestream",6]],["result",6]]],[11,"parse","","",177,[[["parsestream",6]],["result",6]]],[11,"parse","","",176,[[["parsestream",6]],["result",6]]],[11,"parse","","",181,[[["parsestream",6]],["result",6]]],[11,"parse","","",171,[[["parsestream",6]],["result",6]]],[11,"parse","","",170,[[["parsestream",6]],["result",6]]],[11,"parse","","",194,[[["parsestream",6]],["result",6]]],[11,"parse","","",192,[[["parsestream",6]],["result",6]]],[11,"parse","","",189,[[["parsestream",6]],["result",6]]],[11,"parse","","",193,[[["parsestream",6]],["result",6]]],[11,"parse","","",196,[[["parsestream",6]],["result",6]]],[11,"parse","","",190,[[["parsestream",6]],["result",6]]],[11,"parse","syn::parse","",245,[[["parsestream",6]],["result",6]]],[11,"drop","","",113,[[]]],[11,"from","syn","",198,[[["selfvalue",3]],["ident",3]]],[11,"from","","",198,[[["selftype",3]],["ident",3]]],[11,"from","","",198,[[["super",3]],["ident",3]]],[11,"from","","",198,[[["crate",3]],["ident",3]]],[11,"from","","",198,[[["extern",3]],["ident",3]]],[11,"from","","",198,[[["underscore",3]],["ident",3]]],[11,"from","","",118,[[["path",3]],["meta",4]]],[11,"from","","",118,[[["metalist",3]],["meta",4]]],[11,"from","","",118,[[["metanamevalue",3]],["meta",4]]],[11,"from","","",121,[[["meta",4]],["nestedmeta",4]]],[11,"from","","",121,[[["lit",4]],["nestedmeta",4]]],[11,"from","","",123,[[["fieldsnamed",3]],["fields",4]]],[11,"from","","",123,[[["fieldsunnamed",3]],["fields",4]]],[11,"from","","",130,[[["vispublic",3]],["visibility",4]]],[11,"from","","",130,[[["viscrate",3]],["visibility",4]]],[11,"from","","",130,[[["visrestricted",3]],["visibility",4]]],[11,"from","","",131,[[["exprarray",3]],["expr",4]]],[11,"from","","",131,[[["exprassign",3]],["expr",4]]],[11,"from","","",131,[[["exprassignop",3]],["expr",4]]],[11,"from","","",131,[[["exprasync",3]],["expr",4]]],[11,"from","","",131,[[["exprawait",3]],["expr",4]]],[11,"from","","",131,[[["exprbinary",3]],["expr",4]]],[11,"from","","",131,[[["exprblock",3]],["expr",4]]],[11,"from","","",131,[[["exprbox",3]],["expr",4]]],[11,"from","","",131,[[["exprbreak",3]],["expr",4]]],[11,"from","","",131,[[["exprcall",3]],["expr",4]]],[11,"from","","",131,[[["exprcast",3]],["expr",4]]],[11,"from","","",131,[[["exprclosure",3]],["expr",4]]],[11,"from","","",131,[[["exprcontinue",3]],["expr",4]]],[11,"from","","",131,[[["exprfield",3]],["expr",4]]],[11,"from","","",131,[[["exprforloop",3]],["expr",4]]],[11,"from","","",131,[[["exprgroup",3]],["expr",4]]],[11,"from","","",131,[[["exprif",3]],["expr",4]]],[11,"from","","",131,[[["exprindex",3]],["expr",4]]],[11,"from","","",131,[[["exprlet",3]],["expr",4]]],[11,"from","","",131,[[["exprlit",3]],["expr",4]]],[11,"from","","",131,[[["exprloop",3]],["expr",4]]],[11,"from","","",131,[[["exprmacro",3]],["expr",4]]],[11,"from","","",131,[[["exprmatch",3]],["expr",4]]],[11,"from","","",131,[[["exprmethodcall",3]],["expr",4]]],[11,"from","","",131,[[["exprparen",3]],["expr",4]]],[11,"from","","",131,[[["exprpath",3]],["expr",4]]],[11,"from","","",131,[[["exprrange",3]],["expr",4]]],[11,"from","","",131,[[["exprreference",3]],["expr",4]]],[11,"from","","",131,[[["exprrepeat",3]],["expr",4]]],[11,"from","","",131,[[["exprreturn",3]],["expr",4]]],[11,"from","","",131,[[["exprstruct",3]],["expr",4]]],[11,"from","","",131,[[["exprtry",3]],["expr",4]]],[11,"from","","",131,[[["exprtryblock",3]],["expr",4]]],[11,"from","","",131,[[["exprtuple",3]],["expr",4]]],[11,"from","","",131,[[["exprtype",3]],["expr",4]]],[11,"from","","",131,[[["exprunary",3]],["expr",4]]],[11,"from","","",131,[[["exprunsafe",3]],["expr",4]]],[11,"from","","",131,[[["exprwhile",3]],["expr",4]]],[11,"from","","",131,[[["expryield",3]],["expr",4]]],[11,"from","","",141,[[],["index",3]]],[11,"from","","",145,[[["typeparam",3]],["genericparam",4]]],[11,"from","","",145,[[["lifetimedef",3]],["genericparam",4]]],[11,"from","","",145,[[["constparam",3]],["genericparam",4]]],[11,"from","","",153,[[["ident",3]]]],[11,"from","","",154,[[["traitbound",3]],["typeparambound",4]]],[11,"from","","",154,[[["lifetime",3]],["typeparambound",4]]],[11,"from","","",156,[[["predicatetype",3]],["wherepredicate",4]]],[11,"from","","",156,[[["predicatelifetime",3]],["wherepredicate",4]]],[11,"from","","",156,[[["predicateeq",3]],["wherepredicate",4]]],[11,"from","","",158,[[["litstr",3]],["lit",4]]],[11,"from","","",158,[[["litbytestr",3]],["lit",4]]],[11,"from","","",158,[[["litbyte",3]],["lit",4]]],[11,"from","","",158,[[["litchar",3]],["lit",4]]],[11,"from","","",158,[[["litint",3]],["lit",4]]],[11,"from","","",158,[[["litfloat",3]],["lit",4]]],[11,"from","","",158,[[["litbool",3]],["lit",4]]],[11,"from","","",236,[[["literal",3]]]],[11,"from","","",237,[[["literal",3]]]],[11,"from","","",163,[[["datastruct",3]],["data",4]]],[11,"from","","",163,[[["dataenum",3]],["data",4]]],[11,"from","","",163,[[["dataunion",3]],["data",4]]],[11,"from","","",173,[[["typearray",3]],["type",4]]],[11,"from","","",173,[[["typebarefn",3]],["type",4]]],[11,"from","","",173,[[["typegroup",3]],["type",4]]],[11,"from","","",173,[[["typeimpltrait",3]],["type",4]]],[11,"from","","",173,[[["typeinfer",3]],["type",4]]],[11,"from","","",173,[[["typemacro",3]],["type",4]]],[11,"from","","",173,[[["typenever",3]],["type",4]]],[11,"from","","",173,[[["typeparen",3]],["type",4]]],[11,"from","","",173,[[["typepath",3]],["type",4]]],[11,"from","","",173,[[["typeptr",3]],["type",4]]],[11,"from","","",173,[[["typereference",3]],["type",4]]],[11,"from","","",173,[[["typeslice",3]],["type",4]]],[11,"from","","",173,[[["typetraitobject",3]],["type",4]]],[11,"from","","",173,[[["typetuple",3]],["type",4]]],[11,"from","","",194,[[]]],[11,"from","","",196,[[]]],[11,"from","syn::parse","",115,[[["lexerror",3]]]],[11,"next_back","syn::punctuated","",238,[[],["option",4]]],[11,"next_back","","",239,[[],["option",4]]],[11,"next_back","","",240,[[],["option",4]]],[11,"next_back","","",241,[[],["option",4]]],[11,"next_back","","",242,[[],["option",4]]],[11,"next_back","","",243,[[],["option",4]]],[11,"len","","",238,[[]]],[11,"len","","",239,[[]]],[11,"len","","",240,[[]]],[11,"len","","",241,[[]]],[11,"len","","",242,[[]]],[11,"len","","",243,[[]]],[11,"extend","","",106,[[["intoiterator",8]]]],[11,"extend","","",106,[[["intoiterator",8]]]],[11,"extend","syn::parse","",115,[[["intoiterator",8]]]],[11,"into_iter","syn","",123,[[]]],[11,"into_iter","syn::punctuated","",106,[[]]],[11,"into_iter","syn::parse","",115,[[]]],[11,"next","syn::punctuated","",238,[[],["option",4]]],[11,"size_hint","","",238,[[]]],[11,"next","","",239,[[],["option",4]]],[11,"size_hint","","",239,[[]]],[11,"next","","",240,[[],["option",4]]],[11,"size_hint","","",240,[[]]],[11,"next","","",241,[[],["option",4]]],[11,"size_hint","","",241,[[]]],[11,"next","","",242,[[],["option",4]]],[11,"size_hint","","",242,[[]]],[11,"next","","",243,[[],["option",4]]],[11,"size_hint","","",243,[[]]],[11,"clone","syn::token","",0,[[]]],[11,"clone","","",1,[[]]],[11,"clone","","",2,[[]]],[11,"clone","","",3,[[]]],[11,"clone","","",4,[[]]],[11,"clone","","",5,[[]]],[11,"clone","","",6,[[]]],[11,"clone","","",7,[[]]],[11,"clone","","",8,[[]]],[11,"clone","","",9,[[]]],[11,"clone","","",10,[[]]],[11,"clone","","",11,[[]]],[11,"clone","","",12,[[]]],[11,"clone","","",13,[[]]],[11,"clone","","",14,[[]]],[11,"clone","","",15,[[]]],[11,"clone","","",16,[[]]],[11,"clone","","",17,[[]]],[11,"clone","","",18,[[]]],[11,"clone","","",19,[[]]],[11,"clone","","",20,[[]]],[11,"clone","","",21,[[]]],[11,"clone","","",22,[[]]],[11,"clone","","",23,[[]]],[11,"clone","","",24,[[]]],[11,"clone","","",25,[[]]],[11,"clone","","",26,[[]]],[11,"clone","","",27,[[]]],[11,"clone","","",28,[[]]],[11,"clone","","",29,[[]]],[11,"clone","","",30,[[]]],[11,"clone","","",31,[[]]],[11,"clone","","",32,[[]]],[11,"clone","","",33,[[]]],[11,"clone","","",34,[[]]],[11,"clone","","",35,[[]]],[11,"clone","","",36,[[]]],[11,"clone","","",37,[[]]],[11,"clone","","",38,[[]]],[11,"clone","","",39,[[]]],[11,"clone","","",40,[[]]],[11,"clone","","",41,[[]]],[11,"clone","","",42,[[]]],[11,"clone","","",43,[[]]],[11,"clone","","",44,[[]]],[11,"clone","","",45,[[]]],[11,"clone","","",46,[[]]],[11,"clone","","",47,[[]]],[11,"clone","","",48,[[]]],[11,"clone","","",49,[[]]],[11,"clone","","",50,[[]]],[11,"clone","","",51,[[]]],[11,"clone","","",52,[[]]],[11,"clone","","",53,[[]]],[11,"clone","","",54,[[]]],[11,"clone","","",55,[[]]],[11,"clone","","",56,[[]]],[11,"clone","","",57,[[]]],[11,"clone","","",58,[[]]],[11,"clone","","",59,[[]]],[11,"clone","","",60,[[]]],[11,"clone","","",61,[[]]],[11,"clone","","",62,[[]]],[11,"clone","","",63,[[]]],[11,"clone","","",64,[[]]],[11,"clone","","",65,[[]]],[11,"clone","","",66,[[]]],[11,"clone","","",67,[[]]],[11,"clone","","",68,[[]]],[11,"clone","","",69,[[]]],[11,"clone","","",70,[[]]],[11,"clone","","",71,[[]]],[11,"clone","","",72,[[]]],[11,"clone","","",73,[[]]],[11,"clone","","",74,[[]]],[11,"clone","","",75,[[]]],[11,"clone","","",76,[[]]],[11,"clone","","",77,[[]]],[11,"clone","","",78,[[]]],[11,"clone","","",79,[[]]],[11,"clone","","",80,[[]]],[11,"clone","","",81,[[]]],[11,"clone","","",82,[[]]],[11,"clone","","",83,[[]]],[11,"clone","","",84,[[]]],[11,"clone","","",85,[[]]],[11,"clone","","",86,[[]]],[11,"clone","","",87,[[]]],[11,"clone","","",88,[[]]],[11,"clone","","",89,[[]]],[11,"clone","","",90,[[]]],[11,"clone","","",91,[[]]],[11,"clone","","",92,[[]]],[11,"clone","","",93,[[]]],[11,"clone","","",94,[[]]],[11,"clone","","",95,[[]]],[11,"clone","","",96,[[]]],[11,"clone","","",97,[[]]],[11,"clone","","",98,[[]]],[11,"clone","","",99,[[]]],[11,"clone","","",100,[[]]],[11,"clone","","",101,[[]]],[11,"clone","","",102,[[]]],[11,"clone","syn","",229,[[]]],[11,"clone","","",230,[[]]],[11,"clone","","",231,[[]]],[11,"clone","","",157,[[]]],[11,"clone","","",232,[[]]],[11,"clone","","",233,[[]]],[11,"clone","","",234,[[]]],[11,"clone","","",235,[[]]],[11,"clone","","",236,[[]]],[11,"clone","","",237,[[]]],[11,"clone","syn::buffer","",104,[[]]],[11,"clone","syn::punctuated","",106,[[]]],[11,"clone","","",238,[[]]],[11,"clone","","",240,[[]]],[11,"clone","","",241,[[]]],[11,"clone","","",242,[[]]],[11,"clone","","",107,[[]]],[11,"clone","syn","",170,[[]]],[11,"clone","","",189,[[]]],[11,"clone","","",116,[[]]],[11,"clone","","",117,[[]]],[11,"clone","","",171,[[]]],[11,"clone","","",168,[[]]],[11,"clone","","",190,[[]]],[11,"clone","","",143,[[]]],[11,"clone","","",144,[[]]],[11,"clone","","",191,[[]]],[11,"clone","","",163,[[]]],[11,"clone","","",164,[[]]],[11,"clone","","",165,[[]]],[11,"clone","","",166,[[]]],[11,"clone","","",167,[[]]],[11,"clone","","",131,[[]]],[11,"clone","","",132,[[]]],[11,"clone","","",133,[[]]],[11,"clone","","",134,[[]]],[11,"clone","","",135,[[]]],[11,"clone","","",136,[[]]],[11,"clone","","",137,[[]]],[11,"clone","","",138,[[]]],[11,"clone","","",139,[[]]],[11,"clone","","",140,[[]]],[11,"clone","","",122,[[]]],[11,"clone","","",123,[[]]],[11,"clone","","",124,[[]]],[11,"clone","","",125,[[]]],[11,"clone","","",192,[[]]],[11,"clone","","",145,[[]]],[11,"clone","","",146,[[]]],[11,"clone","","",141,[[]]],[11,"clone","","",147,[[]]],[11,"clone","","",158,[[]]],[11,"clone","","",159,[[]]],[11,"clone","","",161,[[]]],[11,"clone","","",162,[[]]],[11,"clone","","",142,[[]]],[11,"clone","","",118,[[]]],[11,"clone","","",119,[[]]],[11,"clone","","",120,[[]]],[11,"clone","","",121,[[]]],[11,"clone","","",193,[[]]],[11,"clone","","",194,[[]]],[11,"clone","","",195,[[]]],[11,"clone","","",196,[[]]],[11,"clone","","",148,[[]]],[11,"clone","","",149,[[]]],[11,"clone","","",150,[[]]],[11,"clone","","",197,[[]]],[11,"clone","","",172,[[]]],[11,"clone","","",151,[[]]],[11,"clone","","",152,[[]]],[11,"clone","","",173,[[]]],[11,"clone","","",174,[[]]],[11,"clone","","",175,[[]]],[11,"clone","","",176,[[]]],[11,"clone","","",177,[[]]],[11,"clone","","",178,[[]]],[11,"clone","","",179,[[]]],[11,"clone","","",180,[[]]],[11,"clone","","",153,[[]]],[11,"clone","","",154,[[]]],[11,"clone","","",181,[[]]],[11,"clone","","",182,[[]]],[11,"clone","","",183,[[]]],[11,"clone","","",184,[[]]],[11,"clone","","",185,[[]]],[11,"clone","","",186,[[]]],[11,"clone","","",187,[[]]],[11,"clone","","",169,[[]]],[11,"clone","","",188,[[]]],[11,"clone","","",126,[[]]],[11,"clone","","",127,[[]]],[11,"clone","","",128,[[]]],[11,"clone","","",129,[[]]],[11,"clone","","",130,[[]]],[11,"clone","","",155,[[]]],[11,"clone","","",156,[[]]],[11,"clone","syn::parse","",112,[[]]],[11,"clone","","",115,[[]]],[11,"default","syn::token","",0,[[]]],[11,"default","","",1,[[]]],[11,"default","","",2,[[]]],[11,"default","","",3,[[]]],[11,"default","","",4,[[]]],[11,"default","","",5,[[]]],[11,"default","","",6,[[]]],[11,"default","","",7,[[]]],[11,"default","","",8,[[]]],[11,"default","","",9,[[]]],[11,"default","","",10,[[]]],[11,"default","","",11,[[]]],[11,"default","","",12,[[]]],[11,"default","","",13,[[]]],[11,"default","","",14,[[]]],[11,"default","","",15,[[]]],[11,"default","","",16,[[]]],[11,"default","","",17,[[]]],[11,"default","","",18,[[]]],[11,"default","","",19,[[]]],[11,"default","","",20,[[]]],[11,"default","","",21,[[]]],[11,"default","","",22,[[]]],[11,"default","","",23,[[]]],[11,"default","","",24,[[]]],[11,"default","","",25,[[]]],[11,"default","","",26,[[]]],[11,"default","","",27,[[]]],[11,"default","","",28,[[]]],[11,"default","","",29,[[]]],[11,"default","","",30,[[]]],[11,"default","","",31,[[]]],[11,"default","","",32,[[]]],[11,"default","","",33,[[]]],[11,"default","","",34,[[]]],[11,"default","","",35,[[]]],[11,"default","","",36,[[]]],[11,"default","","",37,[[]]],[11,"default","","",38,[[]]],[11,"default","","",39,[[]]],[11,"default","","",40,[[]]],[11,"default","","",41,[[]]],[11,"default","","",42,[[]]],[11,"default","","",43,[[]]],[11,"default","","",44,[[]]],[11,"default","","",45,[[]]],[11,"default","","",46,[[]]],[11,"default","","",47,[[]]],[11,"default","","",48,[[]]],[11,"default","","",49,[[]]],[11,"default","","",50,[[]]],[11,"default","","",51,[[]]],[11,"default","","",52,[[]]],[11,"default","","",53,[[]]],[11,"default","","",54,[[]]],[11,"default","","",55,[[]]],[11,"default","","",56,[[]]],[11,"default","","",57,[[]]],[11,"default","","",58,[[]]],[11,"default","","",59,[[]]],[11,"default","","",60,[[]]],[11,"default","","",61,[[]]],[11,"default","","",62,[[]]],[11,"default","","",63,[[]]],[11,"default","","",64,[[]]],[11,"default","","",65,[[]]],[11,"default","","",66,[[]]],[11,"default","","",67,[[]]],[11,"default","","",68,[[]]],[11,"default","","",69,[[]]],[11,"default","","",70,[[]]],[11,"default","","",71,[[]]],[11,"default","","",72,[[]]],[11,"default","","",73,[[]]],[11,"default","","",74,[[]]],[11,"default","","",75,[[]]],[11,"default","","",76,[[]]],[11,"default","","",77,[[]]],[11,"default","","",78,[[]]],[11,"default","","",79,[[]]],[11,"default","","",80,[[]]],[11,"default","","",81,[[]]],[11,"default","","",82,[[]]],[11,"default","","",83,[[]]],[11,"default","","",84,[[]]],[11,"default","","",85,[[]]],[11,"default","","",86,[[]]],[11,"default","","",87,[[]]],[11,"default","","",88,[[]]],[11,"default","","",89,[[]]],[11,"default","","",90,[[]]],[11,"default","","",91,[[]]],[11,"default","","",92,[[]]],[11,"default","","",93,[[]]],[11,"default","","",94,[[]]],[11,"default","","",95,[[]]],[11,"default","","",96,[[]]],[11,"default","","",97,[[]]],[11,"default","","",98,[[]]],[11,"default","","",99,[[]]],[11,"default","","",100,[[]]],[11,"default","","",101,[[]]],[11,"default","","",102,[[]]],[11,"default","syn","",146,[[]]],[11,"default","","",143,[[]]],[11,"default","","",195,[[]]],[11,"default","syn::punctuated","",106,[[]]],[11,"cmp","syn","",157,[[["lifetime",3]],["ordering",4]]],[11,"eq","syn::token","",0,[[["underscore",3]]]],[11,"eq","","",1,[[["abstract",3]]]],[11,"eq","","",2,[[["as",3]]]],[11,"eq","","",3,[[["async",3]]]],[11,"eq","","",4,[[["auto",3]]]],[11,"eq","","",5,[[["await",3]]]],[11,"eq","","",6,[[["become",3]]]],[11,"eq","","",7,[[["box",3]]]],[11,"eq","","",8,[[["break",3]]]],[11,"eq","","",9,[[["const",3]]]],[11,"eq","","",10,[[["continue",3]]]],[11,"eq","","",11,[[["crate",3]]]],[11,"eq","","",12,[[["default",3]]]],[11,"eq","","",13,[[["do",3]]]],[11,"eq","","",14,[[["dyn",3]]]],[11,"eq","","",15,[[["else",3]]]],[11,"eq","","",16,[[["enum",3]]]],[11,"eq","","",17,[[["extern",3]]]],[11,"eq","","",18,[[["final",3]]]],[11,"eq","","",19,[[["fn",3]]]],[11,"eq","","",20,[[["for",3]]]],[11,"eq","","",21,[[["if",3]]]],[11,"eq","","",22,[[["impl",3]]]],[11,"eq","","",23,[[["in",3]]]],[11,"eq","","",24,[[["let",3]]]],[11,"eq","","",25,[[["loop",3]]]],[11,"eq","","",26,[[["macro",3]]]],[11,"eq","","",27,[[["match",3]]]],[11,"eq","","",28,[[["mod",3]]]],[11,"eq","","",29,[[["move",3]]]],[11,"eq","","",30,[[["mut",3]]]],[11,"eq","","",31,[[["override",3]]]],[11,"eq","","",32,[[["priv",3]]]],[11,"eq","","",33,[[["pub",3]]]],[11,"eq","","",34,[[["ref",3]]]],[11,"eq","","",35,[[["return",3]]]],[11,"eq","","",36,[[["selftype",3]]]],[11,"eq","","",37,[[["selfvalue",3]]]],[11,"eq","","",38,[[["static",3]]]],[11,"eq","","",39,[[["struct",3]]]],[11,"eq","","",40,[[["super",3]]]],[11,"eq","","",41,[[["trait",3]]]],[11,"eq","","",42,[[["try",3]]]],[11,"eq","","",43,[[["type",3]]]],[11,"eq","","",44,[[["typeof",3]]]],[11,"eq","","",45,[[["union",3]]]],[11,"eq","","",46,[[["unsafe",3]]]],[11,"eq","","",47,[[["unsized",3]]]],[11,"eq","","",48,[[["use",3]]]],[11,"eq","","",49,[[["virtual",3]]]],[11,"eq","","",50,[[["where",3]]]],[11,"eq","","",51,[[["while",3]]]],[11,"eq","","",52,[[["yield",3]]]],[11,"eq","","",53,[[["add",3]]]],[11,"eq","","",54,[[["addeq",3]]]],[11,"eq","","",55,[[["and",3]]]],[11,"eq","","",56,[[["andand",3]]]],[11,"eq","","",57,[[["andeq",3]]]],[11,"eq","","",58,[[["at",3]]]],[11,"eq","","",59,[[["bang",3]]]],[11,"eq","","",60,[[["caret",3]]]],[11,"eq","","",61,[[["careteq",3]]]],[11,"eq","","",62,[[["colon",3]]]],[11,"eq","","",63,[[["colon2",3]]]],[11,"eq","","",64,[[["comma",3]]]],[11,"eq","","",65,[[["div",3]]]],[11,"eq","","",66,[[["diveq",3]]]],[11,"eq","","",67,[[["dollar",3]]]],[11,"eq","","",68,[[["dot",3]]]],[11,"eq","","",69,[[["dot2",3]]]],[11,"eq","","",70,[[["dot3",3]]]],[11,"eq","","",71,[[["dotdoteq",3]]]],[11,"eq","","",72,[[["eq",3]]]],[11,"eq","","",73,[[["eqeq",3]]]],[11,"eq","","",74,[[["ge",3]]]],[11,"eq","","",75,[[["gt",3]]]],[11,"eq","","",76,[[["le",3]]]],[11,"eq","","",77,[[["lt",3]]]],[11,"eq","","",78,[[["muleq",3]]]],[11,"eq","","",79,[[["ne",3]]]],[11,"eq","","",80,[[["or",3]]]],[11,"eq","","",81,[[["oreq",3]]]],[11,"eq","","",82,[[["oror",3]]]],[11,"eq","","",83,[[["pound",3]]]],[11,"eq","","",84,[[["question",3]]]],[11,"eq","","",85,[[["rarrow",3]]]],[11,"eq","","",86,[[["larrow",3]]]],[11,"eq","","",87,[[["rem",3]]]],[11,"eq","","",88,[[["remeq",3]]]],[11,"eq","","",89,[[["fatarrow",3]]]],[11,"eq","","",90,[[["semi",3]]]],[11,"eq","","",91,[[["shl",3]]]],[11,"eq","","",92,[[["shleq",3]]]],[11,"eq","","",93,[[["shr",3]]]],[11,"eq","","",94,[[["shreq",3]]]],[11,"eq","","",95,[[["star",3]]]],[11,"eq","","",96,[[["sub",3]]]],[11,"eq","","",97,[[["subeq",3]]]],[11,"eq","","",98,[[["tilde",3]]]],[11,"eq","","",99,[[["brace",3]]]],[11,"eq","","",100,[[["bracket",3]]]],[11,"eq","","",101,[[["paren",3]]]],[11,"eq","","",102,[[["group",3]]]],[11,"eq","syn","",142,[[]]],[11,"eq","","",141,[[]]],[11,"eq","","",229,[[]]],[11,"eq","","",230,[[]]],[11,"eq","","",231,[[]]],[11,"eq","","",157,[[["lifetime",3]]]],[11,"eq","","",232,[[]]],[11,"eq","","",233,[[]]],[11,"eq","","",234,[[]]],[11,"eq","","",235,[[]]],[11,"eq","","",236,[[]]],[11,"eq","","",237,[[]]],[11,"eq","syn::buffer","",104,[[]]],[11,"eq","syn::punctuated","",106,[[]]],[11,"eq","syn","",170,[[]]],[11,"eq","","",189,[[]]],[11,"eq","","",116,[[]]],[11,"eq","","",117,[[]]],[11,"eq","","",171,[[]]],[11,"eq","","",168,[[]]],[11,"eq","","",190,[[]]],[11,"eq","","",143,[[]]],[11,"eq","","",144,[[]]],[11,"eq","","",191,[[]]],[11,"eq","","",163,[[]]],[11,"eq","","",164,[[]]],[11,"eq","","",165,[[]]],[11,"eq","","",166,[[]]],[11,"eq","","",167,[[]]],[11,"eq","","",131,[[]]],[11,"eq","","",132,[[]]],[11,"eq","","",133,[[]]],[11,"eq","","",134,[[]]],[11,"eq","","",135,[[]]],[11,"eq","","",136,[[]]],[11,"eq","","",137,[[]]],[11,"eq","","",138,[[]]],[11,"eq","","",139,[[]]],[11,"eq","","",140,[[]]],[11,"eq","","",122,[[]]],[11,"eq","","",123,[[]]],[11,"eq","","",124,[[]]],[11,"eq","","",125,[[]]],[11,"eq","","",192,[[]]],[11,"eq","","",145,[[]]],[11,"eq","","",146,[[]]],[11,"eq","","",147,[[]]],[11,"eq","","",158,[[]]],[11,"eq","","",159,[[]]],[11,"eq","","",161,[[]]],[11,"eq","","",162,[[]]],[11,"eq","","",118,[[]]],[11,"eq","","",119,[[]]],[11,"eq","","",120,[[]]],[11,"eq","","",121,[[]]],[11,"eq","","",193,[[]]],[11,"eq","","",194,[[]]],[11,"eq","","",195,[[]]],[11,"eq","","",196,[[]]],[11,"eq","","",148,[[]]],[11,"eq","","",149,[[]]],[11,"eq","","",150,[[]]],[11,"eq","","",197,[[]]],[11,"eq","","",172,[[]]],[11,"eq","","",151,[[]]],[11,"eq","","",152,[[]]],[11,"eq","","",173,[[]]],[11,"eq","","",174,[[]]],[11,"eq","","",175,[[]]],[11,"eq","","",176,[[]]],[11,"eq","","",177,[[]]],[11,"eq","","",178,[[]]],[11,"eq","","",179,[[]]],[11,"eq","","",180,[[]]],[11,"eq","","",153,[[]]],[11,"eq","","",154,[[]]],[11,"eq","","",181,[[]]],[11,"eq","","",182,[[]]],[11,"eq","","",183,[[]]],[11,"eq","","",184,[[]]],[11,"eq","","",185,[[]]],[11,"eq","","",186,[[]]],[11,"eq","","",187,[[]]],[11,"eq","","",169,[[]]],[11,"eq","","",188,[[]]],[11,"eq","","",126,[[]]],[11,"eq","","",127,[[]]],[11,"eq","","",128,[[]]],[11,"eq","","",129,[[]]],[11,"eq","","",130,[[]]],[11,"eq","","",155,[[]]],[11,"eq","","",156,[[]]],[11,"partial_cmp","","",157,[[["lifetime",3]],[["option",4],["ordering",4]]]],[11,"deref","syn::token","",0,[[]]],[11,"deref","","",53,[[]]],[11,"deref","","",55,[[]]],[11,"deref","","",58,[[]]],[11,"deref","","",59,[[]]],[11,"deref","","",60,[[]]],[11,"deref","","",62,[[]]],[11,"deref","","",64,[[]]],[11,"deref","","",65,[[]]],[11,"deref","","",67,[[]]],[11,"deref","","",68,[[]]],[11,"deref","","",72,[[]]],[11,"deref","","",75,[[]]],[11,"deref","","",77,[[]]],[11,"deref","","",80,[[]]],[11,"deref","","",83,[[]]],[11,"deref","","",84,[[]]],[11,"deref","","",87,[[]]],[11,"deref","","",90,[[]]],[11,"deref","","",95,[[]]],[11,"deref","","",96,[[]]],[11,"deref","","",98,[[]]],[11,"deref","syn::parse","",112,[[]]],[11,"deref_mut","syn::token","",0,[[]]],[11,"deref_mut","","",53,[[]]],[11,"deref_mut","","",55,[[]]],[11,"deref_mut","","",58,[[]]],[11,"deref_mut","","",59,[[]]],[11,"deref_mut","","",60,[[]]],[11,"deref_mut","","",62,[[]]],[11,"deref_mut","","",64,[[]]],[11,"deref_mut","","",65,[[]]],[11,"deref_mut","","",67,[[]]],[11,"deref_mut","","",68,[[]]],[11,"deref_mut","","",72,[[]]],[11,"deref_mut","","",75,[[]]],[11,"deref_mut","","",77,[[]]],[11,"deref_mut","","",80,[[]]],[11,"deref_mut","","",83,[[]]],[11,"deref_mut","","",84,[[]]],[11,"deref_mut","","",87,[[]]],[11,"deref_mut","","",90,[[]]],[11,"deref_mut","","",95,[[]]],[11,"deref_mut","","",96,[[]]],[11,"deref_mut","","",98,[[]]],[11,"fmt","","",0,[[["formatter",3]],["result",6]]],[11,"fmt","","",1,[[["formatter",3]],["result",6]]],[11,"fmt","","",2,[[["formatter",3]],["result",6]]],[11,"fmt","","",3,[[["formatter",3]],["result",6]]],[11,"fmt","","",4,[[["formatter",3]],["result",6]]],[11,"fmt","","",5,[[["formatter",3]],["result",6]]],[11,"fmt","","",6,[[["formatter",3]],["result",6]]],[11,"fmt","","",7,[[["formatter",3]],["result",6]]],[11,"fmt","","",8,[[["formatter",3]],["result",6]]],[11,"fmt","","",9,[[["formatter",3]],["result",6]]],[11,"fmt","","",10,[[["formatter",3]],["result",6]]],[11,"fmt","","",11,[[["formatter",3]],["result",6]]],[11,"fmt","","",12,[[["formatter",3]],["result",6]]],[11,"fmt","","",13,[[["formatter",3]],["result",6]]],[11,"fmt","","",14,[[["formatter",3]],["result",6]]],[11,"fmt","","",15,[[["formatter",3]],["result",6]]],[11,"fmt","","",16,[[["formatter",3]],["result",6]]],[11,"fmt","","",17,[[["formatter",3]],["result",6]]],[11,"fmt","","",18,[[["formatter",3]],["result",6]]],[11,"fmt","","",19,[[["formatter",3]],["result",6]]],[11,"fmt","","",20,[[["formatter",3]],["result",6]]],[11,"fmt","","",21,[[["formatter",3]],["result",6]]],[11,"fmt","","",22,[[["formatter",3]],["result",6]]],[11,"fmt","","",23,[[["formatter",3]],["result",6]]],[11,"fmt","","",24,[[["formatter",3]],["result",6]]],[11,"fmt","","",25,[[["formatter",3]],["result",6]]],[11,"fmt","","",26,[[["formatter",3]],["result",6]]],[11,"fmt","","",27,[[["formatter",3]],["result",6]]],[11,"fmt","","",28,[[["formatter",3]],["result",6]]],[11,"fmt","","",29,[[["formatter",3]],["result",6]]],[11,"fmt","","",30,[[["formatter",3]],["result",6]]],[11,"fmt","","",31,[[["formatter",3]],["result",6]]],[11,"fmt","","",32,[[["formatter",3]],["result",6]]],[11,"fmt","","",33,[[["formatter",3]],["result",6]]],[11,"fmt","","",34,[[["formatter",3]],["result",6]]],[11,"fmt","","",35,[[["formatter",3]],["result",6]]],[11,"fmt","","",36,[[["formatter",3]],["result",6]]],[11,"fmt","","",37,[[["formatter",3]],["result",6]]],[11,"fmt","","",38,[[["formatter",3]],["result",6]]],[11,"fmt","","",39,[[["formatter",3]],["result",6]]],[11,"fmt","","",40,[[["formatter",3]],["result",6]]],[11,"fmt","","",41,[[["formatter",3]],["result",6]]],[11,"fmt","","",42,[[["formatter",3]],["result",6]]],[11,"fmt","","",43,[[["formatter",3]],["result",6]]],[11,"fmt","","",44,[[["formatter",3]],["result",6]]],[11,"fmt","","",45,[[["formatter",3]],["result",6]]],[11,"fmt","","",46,[[["formatter",3]],["result",6]]],[11,"fmt","","",47,[[["formatter",3]],["result",6]]],[11,"fmt","","",48,[[["formatter",3]],["result",6]]],[11,"fmt","","",49,[[["formatter",3]],["result",6]]],[11,"fmt","","",50,[[["formatter",3]],["result",6]]],[11,"fmt","","",51,[[["formatter",3]],["result",6]]],[11,"fmt","","",52,[[["formatter",3]],["result",6]]],[11,"fmt","","",53,[[["formatter",3]],["result",6]]],[11,"fmt","","",54,[[["formatter",3]],["result",6]]],[11,"fmt","","",55,[[["formatter",3]],["result",6]]],[11,"fmt","","",56,[[["formatter",3]],["result",6]]],[11,"fmt","","",57,[[["formatter",3]],["result",6]]],[11,"fmt","","",58,[[["formatter",3]],["result",6]]],[11,"fmt","","",59,[[["formatter",3]],["result",6]]],[11,"fmt","","",60,[[["formatter",3]],["result",6]]],[11,"fmt","","",61,[[["formatter",3]],["result",6]]],[11,"fmt","","",62,[[["formatter",3]],["result",6]]],[11,"fmt","","",63,[[["formatter",3]],["result",6]]],[11,"fmt","","",64,[[["formatter",3]],["result",6]]],[11,"fmt","","",65,[[["formatter",3]],["result",6]]],[11,"fmt","","",66,[[["formatter",3]],["result",6]]],[11,"fmt","","",67,[[["formatter",3]],["result",6]]],[11,"fmt","","",68,[[["formatter",3]],["result",6]]],[11,"fmt","","",69,[[["formatter",3]],["result",6]]],[11,"fmt","","",70,[[["formatter",3]],["result",6]]],[11,"fmt","","",71,[[["formatter",3]],["result",6]]],[11,"fmt","","",72,[[["formatter",3]],["result",6]]],[11,"fmt","","",73,[[["formatter",3]],["result",6]]],[11,"fmt","","",74,[[["formatter",3]],["result",6]]],[11,"fmt","","",75,[[["formatter",3]],["result",6]]],[11,"fmt","","",76,[[["formatter",3]],["result",6]]],[11,"fmt","","",77,[[["formatter",3]],["result",6]]],[11,"fmt","","",78,[[["formatter",3]],["result",6]]],[11,"fmt","","",79,[[["formatter",3]],["result",6]]],[11,"fmt","","",80,[[["formatter",3]],["result",6]]],[11,"fmt","","",81,[[["formatter",3]],["result",6]]],[11,"fmt","","",82,[[["formatter",3]],["result",6]]],[11,"fmt","","",83,[[["formatter",3]],["result",6]]],[11,"fmt","","",84,[[["formatter",3]],["result",6]]],[11,"fmt","","",85,[[["formatter",3]],["result",6]]],[11,"fmt","","",86,[[["formatter",3]],["result",6]]],[11,"fmt","","",87,[[["formatter",3]],["result",6]]],[11,"fmt","","",88,[[["formatter",3]],["result",6]]],[11,"fmt","","",89,[[["formatter",3]],["result",6]]],[11,"fmt","","",90,[[["formatter",3]],["result",6]]],[11,"fmt","","",91,[[["formatter",3]],["result",6]]],[11,"fmt","","",92,[[["formatter",3]],["result",6]]],[11,"fmt","","",93,[[["formatter",3]],["result",6]]],[11,"fmt","","",94,[[["formatter",3]],["result",6]]],[11,"fmt","","",95,[[["formatter",3]],["result",6]]],[11,"fmt","","",96,[[["formatter",3]],["result",6]]],[11,"fmt","","",97,[[["formatter",3]],["result",6]]],[11,"fmt","","",98,[[["formatter",3]],["result",6]]],[11,"fmt","","",99,[[["formatter",3]],["result",6]]],[11,"fmt","","",100,[[["formatter",3]],["result",6]]],[11,"fmt","","",101,[[["formatter",3]],["result",6]]],[11,"fmt","","",102,[[["formatter",3]],["result",6]]],[11,"fmt","syn","",229,[[["formatter",3]],["result",6]]],[11,"fmt","","",230,[[["formatter",3]],["result",6]]],[11,"fmt","","",231,[[["formatter",3]],["result",6]]],[11,"fmt","","",232,[[["formatter",3]],["result",6]]],[11,"fmt","","",233,[[["formatter",3]],["result",6]]],[11,"fmt","","",234,[[["formatter",3]],["result",6]]],[11,"fmt","","",235,[[["formatter",3]],["result",6]]],[11,"fmt","","",236,[[["formatter",3]],["result",6]]],[11,"fmt","","",237,[[["formatter",3]],["result",6]]],[11,"fmt","","",159,[[["formatter",3]],["result",6]]],[11,"fmt","syn::punctuated","",106,[[["formatter",3]],["result",6]]],[11,"fmt","syn","",170,[[["formatter",3]],["result",6]]],[11,"fmt","","",189,[[["formatter",3]],["result",6]]],[11,"fmt","","",116,[[["formatter",3]],["result",6]]],[11,"fmt","","",117,[[["formatter",3]],["result",6]]],[11,"fmt","","",171,[[["formatter",3]],["result",6]]],[11,"fmt","","",168,[[["formatter",3]],["result",6]]],[11,"fmt","","",190,[[["formatter",3]],["result",6]]],[11,"fmt","","",143,[[["formatter",3]],["result",6]]],[11,"fmt","","",144,[[["formatter",3]],["result",6]]],[11,"fmt","","",191,[[["formatter",3]],["result",6]]],[11,"fmt","","",163,[[["formatter",3]],["result",6]]],[11,"fmt","","",164,[[["formatter",3]],["result",6]]],[11,"fmt","","",165,[[["formatter",3]],["result",6]]],[11,"fmt","","",166,[[["formatter",3]],["result",6]]],[11,"fmt","","",167,[[["formatter",3]],["result",6]]],[11,"fmt","","",131,[[["formatter",3]],["result",6]]],[11,"fmt","","",132,[[["formatter",3]],["result",6]]],[11,"fmt","","",133,[[["formatter",3]],["result",6]]],[11,"fmt","","",134,[[["formatter",3]],["result",6]]],[11,"fmt","","",135,[[["formatter",3]],["result",6]]],[11,"fmt","","",136,[[["formatter",3]],["result",6]]],[11,"fmt","","",137,[[["formatter",3]],["result",6]]],[11,"fmt","","",138,[[["formatter",3]],["result",6]]],[11,"fmt","","",139,[[["formatter",3]],["result",6]]],[11,"fmt","","",140,[[["formatter",3]],["result",6]]],[11,"fmt","","",122,[[["formatter",3]],["result",6]]],[11,"fmt","","",123,[[["formatter",3]],["result",6]]],[11,"fmt","","",124,[[["formatter",3]],["result",6]]],[11,"fmt","","",125,[[["formatter",3]],["result",6]]],[11,"fmt","","",192,[[["formatter",3]],["result",6]]],[11,"fmt","","",145,[[["formatter",3]],["result",6]]],[11,"fmt","","",146,[[["formatter",3]],["result",6]]],[11,"fmt","","",141,[[["formatter",3]],["result",6]]],[11,"fmt","","",157,[[["formatter",3]],["result",6]]],[11,"fmt","","",147,[[["formatter",3]],["result",6]]],[11,"fmt","","",158,[[["formatter",3]],["result",6]]],[11,"fmt","","",161,[[["formatter",3]],["result",6]]],[11,"fmt","","",162,[[["formatter",3]],["result",6]]],[11,"fmt","","",142,[[["formatter",3]],["result",6]]],[11,"fmt","","",118,[[["formatter",3]],["result",6]]],[11,"fmt","","",119,[[["formatter",3]],["result",6]]],[11,"fmt","","",120,[[["formatter",3]],["result",6]]],[11,"fmt","","",121,[[["formatter",3]],["result",6]]],[11,"fmt","","",193,[[["formatter",3]],["result",6]]],[11,"fmt","","",194,[[["formatter",3]],["result",6]]],[11,"fmt","","",195,[[["formatter",3]],["result",6]]],[11,"fmt","","",196,[[["formatter",3]],["result",6]]],[11,"fmt","","",148,[[["formatter",3]],["result",6]]],[11,"fmt","","",149,[[["formatter",3]],["result",6]]],[11,"fmt","","",150,[[["formatter",3]],["result",6]]],[11,"fmt","","",197,[[["formatter",3]],["result",6]]],[11,"fmt","","",172,[[["formatter",3]],["result",6]]],[11,"fmt","","",151,[[["formatter",3]],["result",6]]],[11,"fmt","","",152,[[["formatter",3]],["result",6]]],[11,"fmt","","",173,[[["formatter",3]],["result",6]]],[11,"fmt","","",174,[[["formatter",3]],["result",6]]],[11,"fmt","","",175,[[["formatter",3]],["result",6]]],[11,"fmt","","",176,[[["formatter",3]],["result",6]]],[11,"fmt","","",177,[[["formatter",3]],["result",6]]],[11,"fmt","","",178,[[["formatter",3]],["result",6]]],[11,"fmt","","",179,[[["formatter",3]],["result",6]]],[11,"fmt","","",180,[[["formatter",3]],["result",6]]],[11,"fmt","","",153,[[["formatter",3]],["result",6]]],[11,"fmt","","",154,[[["formatter",3]],["result",6]]],[11,"fmt","","",181,[[["formatter",3]],["result",6]]],[11,"fmt","","",182,[[["formatter",3]],["result",6]]],[11,"fmt","","",183,[[["formatter",3]],["result",6]]],[11,"fmt","","",184,[[["formatter",3]],["result",6]]],[11,"fmt","","",185,[[["formatter",3]],["result",6]]],[11,"fmt","","",186,[[["formatter",3]],["result",6]]],[11,"fmt","","",187,[[["formatter",3]],["result",6]]],[11,"fmt","","",169,[[["formatter",3]],["result",6]]],[11,"fmt","","",188,[[["formatter",3]],["result",6]]],[11,"fmt","","",126,[[["formatter",3]],["result",6]]],[11,"fmt","","",127,[[["formatter",3]],["result",6]]],[11,"fmt","","",128,[[["formatter",3]],["result",6]]],[11,"fmt","","",129,[[["formatter",3]],["result",6]]],[11,"fmt","","",130,[[["formatter",3]],["result",6]]],[11,"fmt","","",155,[[["formatter",3]],["result",6]]],[11,"fmt","","",156,[[["formatter",3]],["result",6]]],[11,"fmt","syn::parse","",113,[[["formatter",3]],["result",6]]],[11,"fmt","","",115,[[["formatter",3]],["result",6]]],[11,"fmt","syn","",157,[[["formatter",3]],["result",6]]],[11,"fmt","","",236,[[["formatter",3]],["result",6]]],[11,"fmt","","",237,[[["formatter",3]],["result",6]]],[11,"fmt","syn::parse","",113,[[["formatter",3]],["result",6]]],[11,"fmt","","",115,[[["formatter",3]],["result",6]]],[11,"index","syn::punctuated","",106,[[]]],[11,"index_mut","","",106,[[]]],[11,"hash","syn::token","",0,[[]]],[11,"hash","","",1,[[]]],[11,"hash","","",2,[[]]],[11,"hash","","",3,[[]]],[11,"hash","","",4,[[]]],[11,"hash","","",5,[[]]],[11,"hash","","",6,[[]]],[11,"hash","","",7,[[]]],[11,"hash","","",8,[[]]],[11,"hash","","",9,[[]]],[11,"hash","","",10,[[]]],[11,"hash","","",11,[[]]],[11,"hash","","",12,[[]]],[11,"hash","","",13,[[]]],[11,"hash","","",14,[[]]],[11,"hash","","",15,[[]]],[11,"hash","","",16,[[]]],[11,"hash","","",17,[[]]],[11,"hash","","",18,[[]]],[11,"hash","","",19,[[]]],[11,"hash","","",20,[[]]],[11,"hash","","",21,[[]]],[11,"hash","","",22,[[]]],[11,"hash","","",23,[[]]],[11,"hash","","",24,[[]]],[11,"hash","","",25,[[]]],[11,"hash","","",26,[[]]],[11,"hash","","",27,[[]]],[11,"hash","","",28,[[]]],[11,"hash","","",29,[[]]],[11,"hash","","",30,[[]]],[11,"hash","","",31,[[]]],[11,"hash","","",32,[[]]],[11,"hash","","",33,[[]]],[11,"hash","","",34,[[]]],[11,"hash","","",35,[[]]],[11,"hash","","",36,[[]]],[11,"hash","","",37,[[]]],[11,"hash","","",38,[[]]],[11,"hash","","",39,[[]]],[11,"hash","","",40,[[]]],[11,"hash","","",41,[[]]],[11,"hash","","",42,[[]]],[11,"hash","","",43,[[]]],[11,"hash","","",44,[[]]],[11,"hash","","",45,[[]]],[11,"hash","","",46,[[]]],[11,"hash","","",47,[[]]],[11,"hash","","",48,[[]]],[11,"hash","","",49,[[]]],[11,"hash","","",50,[[]]],[11,"hash","","",51,[[]]],[11,"hash","","",52,[[]]],[11,"hash","","",53,[[]]],[11,"hash","","",54,[[]]],[11,"hash","","",55,[[]]],[11,"hash","","",56,[[]]],[11,"hash","","",57,[[]]],[11,"hash","","",58,[[]]],[11,"hash","","",59,[[]]],[11,"hash","","",60,[[]]],[11,"hash","","",61,[[]]],[11,"hash","","",62,[[]]],[11,"hash","","",63,[[]]],[11,"hash","","",64,[[]]],[11,"hash","","",65,[[]]],[11,"hash","","",66,[[]]],[11,"hash","","",67,[[]]],[11,"hash","","",68,[[]]],[11,"hash","","",69,[[]]],[11,"hash","","",70,[[]]],[11,"hash","","",71,[[]]],[11,"hash","","",72,[[]]],[11,"hash","","",73,[[]]],[11,"hash","","",74,[[]]],[11,"hash","","",75,[[]]],[11,"hash","","",76,[[]]],[11,"hash","","",77,[[]]],[11,"hash","","",78,[[]]],[11,"hash","","",79,[[]]],[11,"hash","","",80,[[]]],[11,"hash","","",81,[[]]],[11,"hash","","",82,[[]]],[11,"hash","","",83,[[]]],[11,"hash","","",84,[[]]],[11,"hash","","",85,[[]]],[11,"hash","","",86,[[]]],[11,"hash","","",87,[[]]],[11,"hash","","",88,[[]]],[11,"hash","","",89,[[]]],[11,"hash","","",90,[[]]],[11,"hash","","",91,[[]]],[11,"hash","","",92,[[]]],[11,"hash","","",93,[[]]],[11,"hash","","",94,[[]]],[11,"hash","","",95,[[]]],[11,"hash","","",96,[[]]],[11,"hash","","",97,[[]]],[11,"hash","","",98,[[]]],[11,"hash","","",99,[[]]],[11,"hash","","",100,[[]]],[11,"hash","","",101,[[]]],[11,"hash","","",102,[[]]],[11,"hash","syn","",142,[[]]],[11,"hash","","",141,[[]]],[11,"hash","","",229,[[]]],[11,"hash","","",230,[[]]],[11,"hash","","",231,[[]]],[11,"hash","","",157,[[]]],[11,"hash","","",232,[[]]],[11,"hash","","",233,[[]]],[11,"hash","","",234,[[]]],[11,"hash","","",235,[[]]],[11,"hash","","",236,[[]]],[11,"hash","","",237,[[]]],[11,"hash","syn::punctuated","",106,[[]]],[11,"hash","syn","",170,[[]]],[11,"hash","","",189,[[]]],[11,"hash","","",116,[[]]],[11,"hash","","",117,[[]]],[11,"hash","","",171,[[]]],[11,"hash","","",168,[[]]],[11,"hash","","",190,[[]]],[11,"hash","","",143,[[]]],[11,"hash","","",144,[[]]],[11,"hash","","",191,[[]]],[11,"hash","","",163,[[]]],[11,"hash","","",164,[[]]],[11,"hash","","",165,[[]]],[11,"hash","","",166,[[]]],[11,"hash","","",167,[[]]],[11,"hash","","",131,[[]]],[11,"hash","","",132,[[]]],[11,"hash","","",133,[[]]],[11,"hash","","",134,[[]]],[11,"hash","","",135,[[]]],[11,"hash","","",136,[[]]],[11,"hash","","",137,[[]]],[11,"hash","","",138,[[]]],[11,"hash","","",139,[[]]],[11,"hash","","",140,[[]]],[11,"hash","","",122,[[]]],[11,"hash","","",123,[[]]],[11,"hash","","",124,[[]]],[11,"hash","","",125,[[]]],[11,"hash","","",192,[[]]],[11,"hash","","",145,[[]]],[11,"hash","","",146,[[]]],[11,"hash","","",147,[[]]],[11,"hash","","",158,[[]]],[11,"hash","","",159,[[]]],[11,"hash","","",161,[[]]],[11,"hash","","",162,[[]]],[11,"hash","","",118,[[]]],[11,"hash","","",119,[[]]],[11,"hash","","",120,[[]]],[11,"hash","","",121,[[]]],[11,"hash","","",193,[[]]],[11,"hash","","",194,[[]]],[11,"hash","","",195,[[]]],[11,"hash","","",196,[[]]],[11,"hash","","",148,[[]]],[11,"hash","","",149,[[]]],[11,"hash","","",150,[[]]],[11,"hash","","",197,[[]]],[11,"hash","","",172,[[]]],[11,"hash","","",151,[[]]],[11,"hash","","",152,[[]]],[11,"hash","","",173,[[]]],[11,"hash","","",174,[[]]],[11,"hash","","",175,[[]]],[11,"hash","","",176,[[]]],[11,"hash","","",177,[[]]],[11,"hash","","",178,[[]]],[11,"hash","","",179,[[]]],[11,"hash","","",180,[[]]],[11,"hash","","",153,[[]]],[11,"hash","","",154,[[]]],[11,"hash","","",181,[[]]],[11,"hash","","",182,[[]]],[11,"hash","","",183,[[]]],[11,"hash","","",184,[[]]],[11,"hash","","",185,[[]]],[11,"hash","","",186,[[]]],[11,"hash","","",187,[[]]],[11,"hash","","",169,[[]]],[11,"hash","","",188,[[]]],[11,"hash","","",126,[[]]],[11,"hash","","",127,[[]]],[11,"hash","","",128,[[]]],[11,"hash","","",129,[[]]],[11,"hash","","",130,[[]]],[11,"hash","","",155,[[]]],[11,"hash","","",156,[[]]],[11,"from_iter","syn::punctuated","",106,[[["intoiterator",8]]]],[11,"from_iter","","",106,[[["intoiterator",8]]]],[11,"to_tokens","syn::token","",0,[[["tokenstream",3]]]],[11,"to_tokens","","",1,[[["tokenstream",3]]]],[11,"to_tokens","","",2,[[["tokenstream",3]]]],[11,"to_tokens","","",3,[[["tokenstream",3]]]],[11,"to_tokens","","",4,[[["tokenstream",3]]]],[11,"to_tokens","","",5,[[["tokenstream",3]]]],[11,"to_tokens","","",6,[[["tokenstream",3]]]],[11,"to_tokens","","",7,[[["tokenstream",3]]]],[11,"to_tokens","","",8,[[["tokenstream",3]]]],[11,"to_tokens","","",9,[[["tokenstream",3]]]],[11,"to_tokens","","",10,[[["tokenstream",3]]]],[11,"to_tokens","","",11,[[["tokenstream",3]]]],[11,"to_tokens","","",12,[[["tokenstream",3]]]],[11,"to_tokens","","",13,[[["tokenstream",3]]]],[11,"to_tokens","","",14,[[["tokenstream",3]]]],[11,"to_tokens","","",15,[[["tokenstream",3]]]],[11,"to_tokens","","",16,[[["tokenstream",3]]]],[11,"to_tokens","","",17,[[["tokenstream",3]]]],[11,"to_tokens","","",18,[[["tokenstream",3]]]],[11,"to_tokens","","",19,[[["tokenstream",3]]]],[11,"to_tokens","","",20,[[["tokenstream",3]]]],[11,"to_tokens","","",21,[[["tokenstream",3]]]],[11,"to_tokens","","",22,[[["tokenstream",3]]]],[11,"to_tokens","","",23,[[["tokenstream",3]]]],[11,"to_tokens","","",24,[[["tokenstream",3]]]],[11,"to_tokens","","",25,[[["tokenstream",3]]]],[11,"to_tokens","","",26,[[["tokenstream",3]]]],[11,"to_tokens","","",27,[[["tokenstream",3]]]],[11,"to_tokens","","",28,[[["tokenstream",3]]]],[11,"to_tokens","","",29,[[["tokenstream",3]]]],[11,"to_tokens","","",30,[[["tokenstream",3]]]],[11,"to_tokens","","",31,[[["tokenstream",3]]]],[11,"to_tokens","","",32,[[["tokenstream",3]]]],[11,"to_tokens","","",33,[[["tokenstream",3]]]],[11,"to_tokens","","",34,[[["tokenstream",3]]]],[11,"to_tokens","","",35,[[["tokenstream",3]]]],[11,"to_tokens","","",36,[[["tokenstream",3]]]],[11,"to_tokens","","",37,[[["tokenstream",3]]]],[11,"to_tokens","","",38,[[["tokenstream",3]]]],[11,"to_tokens","","",39,[[["tokenstream",3]]]],[11,"to_tokens","","",40,[[["tokenstream",3]]]],[11,"to_tokens","","",41,[[["tokenstream",3]]]],[11,"to_tokens","","",42,[[["tokenstream",3]]]],[11,"to_tokens","","",43,[[["tokenstream",3]]]],[11,"to_tokens","","",44,[[["tokenstream",3]]]],[11,"to_tokens","","",45,[[["tokenstream",3]]]],[11,"to_tokens","","",46,[[["tokenstream",3]]]],[11,"to_tokens","","",47,[[["tokenstream",3]]]],[11,"to_tokens","","",48,[[["tokenstream",3]]]],[11,"to_tokens","","",49,[[["tokenstream",3]]]],[11,"to_tokens","","",50,[[["tokenstream",3]]]],[11,"to_tokens","","",51,[[["tokenstream",3]]]],[11,"to_tokens","","",52,[[["tokenstream",3]]]],[11,"to_tokens","","",53,[[["tokenstream",3]]]],[11,"to_tokens","","",54,[[["tokenstream",3]]]],[11,"to_tokens","","",55,[[["tokenstream",3]]]],[11,"to_tokens","","",56,[[["tokenstream",3]]]],[11,"to_tokens","","",57,[[["tokenstream",3]]]],[11,"to_tokens","","",58,[[["tokenstream",3]]]],[11,"to_tokens","","",59,[[["tokenstream",3]]]],[11,"to_tokens","","",60,[[["tokenstream",3]]]],[11,"to_tokens","","",61,[[["tokenstream",3]]]],[11,"to_tokens","","",62,[[["tokenstream",3]]]],[11,"to_tokens","","",63,[[["tokenstream",3]]]],[11,"to_tokens","","",64,[[["tokenstream",3]]]],[11,"to_tokens","","",65,[[["tokenstream",3]]]],[11,"to_tokens","","",66,[[["tokenstream",3]]]],[11,"to_tokens","","",67,[[["tokenstream",3]]]],[11,"to_tokens","","",68,[[["tokenstream",3]]]],[11,"to_tokens","","",69,[[["tokenstream",3]]]],[11,"to_tokens","","",70,[[["tokenstream",3]]]],[11,"to_tokens","","",71,[[["tokenstream",3]]]],[11,"to_tokens","","",72,[[["tokenstream",3]]]],[11,"to_tokens","","",73,[[["tokenstream",3]]]],[11,"to_tokens","","",74,[[["tokenstream",3]]]],[11,"to_tokens","","",75,[[["tokenstream",3]]]],[11,"to_tokens","","",76,[[["tokenstream",3]]]],[11,"to_tokens","","",77,[[["tokenstream",3]]]],[11,"to_tokens","","",78,[[["tokenstream",3]]]],[11,"to_tokens","","",79,[[["tokenstream",3]]]],[11,"to_tokens","","",80,[[["tokenstream",3]]]],[11,"to_tokens","","",81,[[["tokenstream",3]]]],[11,"to_tokens","","",82,[[["tokenstream",3]]]],[11,"to_tokens","","",83,[[["tokenstream",3]]]],[11,"to_tokens","","",84,[[["tokenstream",3]]]],[11,"to_tokens","","",85,[[["tokenstream",3]]]],[11,"to_tokens","","",86,[[["tokenstream",3]]]],[11,"to_tokens","","",87,[[["tokenstream",3]]]],[11,"to_tokens","","",88,[[["tokenstream",3]]]],[11,"to_tokens","","",89,[[["tokenstream",3]]]],[11,"to_tokens","","",90,[[["tokenstream",3]]]],[11,"to_tokens","","",91,[[["tokenstream",3]]]],[11,"to_tokens","","",92,[[["tokenstream",3]]]],[11,"to_tokens","","",93,[[["tokenstream",3]]]],[11,"to_tokens","","",94,[[["tokenstream",3]]]],[11,"to_tokens","","",95,[[["tokenstream",3]]]],[11,"to_tokens","","",96,[[["tokenstream",3]]]],[11,"to_tokens","","",97,[[["tokenstream",3]]]],[11,"to_tokens","","",98,[[["tokenstream",3]]]],[11,"to_tokens","syn","",118,[[["tokenstream",3]]]],[11,"to_tokens","","",121,[[["tokenstream",3]]]],[11,"to_tokens","","",117,[[["tokenstream",3]]]],[11,"to_tokens","","",119,[[["tokenstream",3]]]],[11,"to_tokens","","",120,[[["tokenstream",3]]]],[11,"to_tokens","","",123,[[["tokenstream",3]]]],[11,"to_tokens","","",130,[[["tokenstream",3]]]],[11,"to_tokens","","",126,[[["tokenstream",3]]]],[11,"to_tokens","","",124,[[["tokenstream",3]]]],[11,"to_tokens","","",125,[[["tokenstream",3]]]],[11,"to_tokens","","",122,[[["tokenstream",3]]]],[11,"to_tokens","","",128,[[["tokenstream",3]]]],[11,"to_tokens","","",127,[[["tokenstream",3]]]],[11,"to_tokens","","",129,[[["tokenstream",3]]]],[11,"to_tokens","","",131,[[["tokenstream",3]]]],[11,"to_tokens","","",199,[[["tokenstream",3]]]],[11,"to_tokens","","",200,[[["tokenstream",3]]]],[11,"to_tokens","","",201,[[["tokenstream",3]]]],[11,"to_tokens","","",202,[[["tokenstream",3]]]],[11,"to_tokens","","",203,[[["tokenstream",3]]]],[11,"to_tokens","","",204,[[["tokenstream",3]]]],[11,"to_tokens","","",205,[[["tokenstream",3]]]],[11,"to_tokens","","",206,[[["tokenstream",3]]]],[11,"to_tokens","","",207,[[["tokenstream",3]]]],[11,"to_tokens","","",208,[[["tokenstream",3]]]],[11,"to_tokens","","",209,[[["tokenstream",3]]]],[11,"to_tokens","","",210,[[["tokenstream",3]]]],[11,"to_tokens","","",211,[[["tokenstream",3]]]],[11,"to_tokens","","",212,[[["tokenstream",3]]]],[11,"to_tokens","","",213,[[["tokenstream",3]]]],[11,"to_tokens","","",214,[[["tokenstream",3]]]],[11,"to_tokens","","",215,[[["tokenstream",3]]]],[11,"to_tokens","","",216,[[["tokenstream",3]]]],[11,"to_tokens","","",217,[[["tokenstream",3]]]],[11,"to_tokens","","",218,[[["tokenstream",3]]]],[11,"to_tokens","","",219,[[["tokenstream",3]]]],[11,"to_tokens","","",220,[[["tokenstream",3]]]],[11,"to_tokens","","",221,[[["tokenstream",3]]]],[11,"to_tokens","","",222,[[["tokenstream",3]]]],[11,"to_tokens","","",223,[[["tokenstream",3]]]],[11,"to_tokens","","",224,[[["tokenstream",3]]]],[11,"to_tokens","","",225,[[["tokenstream",3]]]],[11,"to_tokens","","",226,[[["tokenstream",3]]]],[11,"to_tokens","","",227,[[["tokenstream",3]]]],[11,"to_tokens","","",228,[[["tokenstream",3]]]],[11,"to_tokens","","",133,[[["tokenstream",3]]]],[11,"to_tokens","","",132,[[["tokenstream",3]]]],[11,"to_tokens","","",140,[[["tokenstream",3]]]],[11,"to_tokens","","",137,[[["tokenstream",3]]]],[11,"to_tokens","","",134,[[["tokenstream",3]]]],[11,"to_tokens","","",135,[[["tokenstream",3]]]],[11,"to_tokens","","",142,[[["tokenstream",3]]]],[11,"to_tokens","","",141,[[["tokenstream",3]]]],[11,"to_tokens","","",136,[[["tokenstream",3]]]],[11,"to_tokens","","",139,[[["tokenstream",3]]]],[11,"to_tokens","","",138,[[["tokenstream",3]]]],[11,"to_tokens","","",145,[[["tokenstream",3]]]],[11,"to_tokens","","",154,[[["tokenstream",3]]]],[11,"to_tokens","","",156,[[["tokenstream",3]]]],[11,"to_tokens","","",146,[[["tokenstream",3]]]],[11,"to_tokens","","",229,[[["tokenstream",3]]]],[11,"to_tokens","","",230,[[["tokenstream",3]]]],[11,"to_tokens","","",231,[[["tokenstream",3]]]],[11,"to_tokens","","",143,[[["tokenstream",3]]]],[11,"to_tokens","","",147,[[["tokenstream",3]]]],[11,"to_tokens","","",153,[[["tokenstream",3]]]],[11,"to_tokens","","",151,[[["tokenstream",3]]]],[11,"to_tokens","","",152,[[["tokenstream",3]]]],[11,"to_tokens","","",144,[[["tokenstream",3]]]],[11,"to_tokens","","",155,[[["tokenstream",3]]]],[11,"to_tokens","","",150,[[["tokenstream",3]]]],[11,"to_tokens","","",149,[[["tokenstream",3]]]],[11,"to_tokens","","",148,[[["tokenstream",3]]]],[11,"to_tokens","","",157,[[["tokenstream",3]]]],[11,"to_tokens","","",158,[[["tokenstream",3]]]],[11,"to_tokens","","",232,[[["tokenstream",3]]]],[11,"to_tokens","","",233,[[["tokenstream",3]]]],[11,"to_tokens","","",234,[[["tokenstream",3]]]],[11,"to_tokens","","",235,[[["tokenstream",3]]]],[11,"to_tokens","","",236,[[["tokenstream",3]]]],[11,"to_tokens","","",237,[[["tokenstream",3]]]],[11,"to_tokens","","",159,[[["tokenstream",3]]]],[11,"to_tokens","","",161,[[["tokenstream",3]]]],[11,"to_tokens","","",167,[[["tokenstream",3]]]],[11,"to_tokens","","",168,[[["tokenstream",3]]]],[11,"to_tokens","","",169,[[["tokenstream",3]]]],[11,"to_tokens","","",173,[[["tokenstream",3]]]],[11,"to_tokens","","",185,[[["tokenstream",3]]]],[11,"to_tokens","","",174,[[["tokenstream",3]]]],[11,"to_tokens","","",183,[[["tokenstream",3]]]],[11,"to_tokens","","",184,[[["tokenstream",3]]]],[11,"to_tokens","","",175,[[["tokenstream",3]]]],[11,"to_tokens","","",180,[[["tokenstream",3]]]],[11,"to_tokens","","",187,[[["tokenstream",3]]]],[11,"to_tokens","","",182,[[["tokenstream",3]]]],[11,"to_tokens","","",186,[[["tokenstream",3]]]],[11,"to_tokens","","",177,[[["tokenstream",3]]]],[11,"to_tokens","","",176,[[["tokenstream",3]]]],[11,"to_tokens","","",181,[[["tokenstream",3]]]],[11,"to_tokens","","",178,[[["tokenstream",3]]]],[11,"to_tokens","","",179,[[["tokenstream",3]]]],[11,"to_tokens","","",172,[[["tokenstream",3]]]],[11,"to_tokens","","",171,[[["tokenstream",3]]]],[11,"to_tokens","","",188,[[["tokenstream",3]]]],[11,"to_tokens","","",170,[[["tokenstream",3]]]],[11,"to_tokens","","",194,[[["tokenstream",3]]]],[11,"to_tokens","","",196,[[["tokenstream",3]]]],[11,"to_tokens","","",195,[[["tokenstream",3]]]],[11,"to_tokens","","",192,[[["tokenstream",3]]]],[11,"to_tokens","","",189,[[["tokenstream",3]]]],[11,"to_tokens","","",190,[[["tokenstream",3]]]],[11,"to_tokens","","",191,[[["tokenstream",3]]]],[11,"to_tokens","","",193,[[["tokenstream",3]]]],[11,"to_tokens","syn::punctuated","",106,[[["tokenstream",3]]]],[11,"to_tokens","","",107,[[["tokenstream",3]]]],[11,"fmt","syn","",142,[[["formatter",3]],["result",6]]],[11,"span","","",142,[[],[["option",4],["span",3]]]],[11,"fmt","","",141,[[["formatter",3]],["result",6]]],[11,"span","","",141,[[],[["option",4],["span",3]]]],[11,"new","","Creates a new Ident with the given string as well as the …",198,[[["span",3]],["ident",3]]],[11,"span","","Returns the span of this Ident.",198,[[],["span",3]]],[11,"set_span","","Configures the span of this Ident, possibly changing its …",198,[[["span",3]]]],[11,"parse_meta","","Parses the content of the attribute, consisting of the …",117,[[],[["result",6],["meta",4]]]],[11,"parse_args","","Parse the arguments to the attribute as a syntax tree.",117,[[],[["result",6],["parse",8]]]],[11,"parse_args_with","","Parse the arguments to the attribute using the given …",117,[[["parser",8]],["result",6]]],[11,"parse_outer","","Parses zero or more outer attributes from the stream.",117,[[["parsestream",6]],[["result",6],["vec",3]]]],[11,"parse_inner","","Parses zero or more inner attributes from the stream.",117,[[["parsestream",6]],[["result",6],["vec",3]]]],[11,"path","","Returns the identifier that begins this structured meta …",118,[[],["path",3]]],[11,"parse_named","","Parses a named (braced struct) field.",122,[[["parsestream",6]],["result",6]]],[11,"parse_unnamed","","Parses an unnamed (tuple struct) field.",122,[[["parsestream",6]],["result",6]]],[11,"iter","","Get an iterator over the borrowed [Field] items in this …",123,[[],[["field",3],["iter",3]]]],[11,"iter_mut","","Get an iterator over the mutably borrowed [Field] items …",123,[[],[["field",3],["itermut",3]]]],[11,"len","","Returns the number of fields.",123,[[]]],[11,"is_empty","","Returns true if there are zero fields.",123,[[]]],[11,"type_params","","Returns an Iterator over the type …",146,[[],["typeparams",3]]],[11,"type_params_mut","","Returns an Iterator over the type …",146,[[],["typeparamsmut",3]]],[11,"lifetimes","","Returns an Iterator over the …",146,[[],["lifetimes",3]]],[11,"lifetimes_mut","","Returns an Iterator over the …",146,[[],["lifetimesmut",3]]],[11,"const_params","","Returns an Iterator over the constant …",146,[[],["constparams",3]]],[11,"const_params_mut","","Returns an Iterator over the …",146,[[],["constparamsmut",3]]],[11,"make_where_clause","","Initializes an empty where-clause if there is not one …",146,[[],["whereclause",3]]],[11,"split_for_impl","","Split a type\'s generics into the pieces required for …",146,[[]]],[11,"as_turbofish","","Turn a type\'s generics like into a turbofish like …",230,[[],["turbofish",3]]],[11,"new","","",147,[[["lifetime",3]]]],[11,"new","","PanicsPanics if the lifetime does not conform to the …",157,[[["span",3]]]],[11,"span","","",157,[[],["span",3]]],[11,"set_span","","",157,[[["span",3]]]],[11,"new","","Interpret a Syn literal from a proc-macro2 literal.",158,[[["literal",3]]]],[11,"suffix","","",158,[[]]],[11,"span","","",158,[[],["span",3]]],[11,"set_span","","",158,[[["span",3]]]],[11,"new","","",232,[[["span",3]]]],[11,"value","","",232,[[],["string",3]]],[11,"parse","","Parse a syntax tree node from the content of this string …",232,[[],[["result",6],["parse",8]]]],[11,"parse_with","","Invoke parser on the content of this string literal.",232,[[["parser",8]],["result",6]]],[11,"span","","",232,[[],["span",3]]],[11,"set_span","","",232,[[["span",3]]]],[11,"suffix","","",232,[[]]],[11,"new","","",233,[[["span",3]]]],[11,"value","","",233,[[],["vec",3]]],[11,"span","","",233,[[],["span",3]]],[11,"set_span","","",233,[[["span",3]]]],[11,"suffix","","",233,[[]]],[11,"new","","",234,[[["span",3]]]],[11,"value","","",234,[[]]],[11,"span","","",234,[[],["span",3]]],[11,"set_span","","",234,[[["span",3]]]],[11,"suffix","","",234,[[]]],[11,"new","","",235,[[["span",3]]]],[11,"value","","",235,[[]]],[11,"span","","",235,[[],["span",3]]],[11,"set_span","","",235,[[["span",3]]]],[11,"suffix","","",235,[[]]],[11,"new","","",236,[[["span",3]]]],[11,"base10_digits","","",236,[[]]],[11,"base10_parse","","Parses the literal into a selected number type.",236,[[],["result",6]]],[11,"suffix","","",236,[[]]],[11,"span","","",236,[[],["span",3]]],[11,"set_span","","",236,[[["span",3]]]],[11,"new","","",237,[[["span",3]]]],[11,"base10_digits","","",237,[[]]],[11,"base10_parse","","",237,[[],["result",6]]],[11,"suffix","","",237,[[]]],[11,"span","","",237,[[],["span",3]]],[11,"set_span","","",237,[[["span",3]]]],[11,"new","","",159,[[["span",3]]]],[11,"value","","",159,[[]]],[11,"span","","",159,[[],["span",3]]],[11,"set_span","","",159,[[["span",3]]]],[11,"parse_body","","Parse the tokens within the macro invocation\'s delimiters …",161,[[],[["result",6],["parse",8]]]],[11,"parse_body_with","","Parse the tokens within the macro invocation\'s delimiters …",161,[[["parser",8]],["result",6]]],[11,"without_plus","","In some positions, types may not contain the + character, …",173,[[["parsestream",6]],["result",6]]],[11,"without_plus","","",172,[[["parsestream",6]],["result",6]]],[11,"without_plus","","",186,[[["parsestream",6]],["result",6]]],[11,"parse_mod_style","","Parse a Path containing no path arguments on any of its …",194,[[["parsestream",6]],["result",6]]],[11,"is_ident","","Determines whether this is a path of length 1 equal to …",194,[[]]],[11,"get_ident","","If this path consists of a single ident, returns the …",194,[[],[["ident",3],["option",4]]]],[11,"is_empty","","",195,[[]]],[11,"visit_abi","syn::visit","",109,[[["abi",3]]]],[11,"visit_angle_bracketed_generic_arguments","","",109,[[["anglebracketedgenericarguments",3]]]],[11,"visit_attr_style","","",109,[[["attrstyle",4]]]],[11,"visit_attribute","","",109,[[["attribute",3]]]],[11,"visit_bare_fn_arg","","",109,[[["barefnarg",3]]]],[11,"visit_bin_op","","",109,[[["binop",4]]]],[11,"visit_binding","","",109,[[["binding",3]]]],[11,"visit_bound_lifetimes","","",109,[[["boundlifetimes",3]]]],[11,"visit_const_param","","",109,[[["constparam",3]]]],[11,"visit_constraint","","",109,[[["constraint",3]]]],[11,"visit_data","","",109,[[["data",4]]]],[11,"visit_data_enum","","",109,[[["dataenum",3]]]],[11,"visit_data_struct","","",109,[[["datastruct",3]]]],[11,"visit_data_union","","",109,[[["dataunion",3]]]],[11,"visit_derive_input","","",109,[[["deriveinput",3]]]],[11,"visit_expr","","",109,[[["expr",4]]]],[11,"visit_expr_binary","","",109,[[["exprbinary",3]]]],[11,"visit_expr_call","","",109,[[["exprcall",3]]]],[11,"visit_expr_cast","","",109,[[["exprcast",3]]]],[11,"visit_expr_field","","",109,[[["exprfield",3]]]],[11,"visit_expr_index","","",109,[[["exprindex",3]]]],[11,"visit_expr_lit","","",109,[[["exprlit",3]]]],[11,"visit_expr_paren","","",109,[[["exprparen",3]]]],[11,"visit_expr_path","","",109,[[["exprpath",3]]]],[11,"visit_expr_unary","","",109,[[["exprunary",3]]]],[11,"visit_field","","",109,[[["field",3]]]],[11,"visit_fields","","",109,[[["fields",4]]]],[11,"visit_fields_named","","",109,[[["fieldsnamed",3]]]],[11,"visit_fields_unnamed","","",109,[[["fieldsunnamed",3]]]],[11,"visit_generic_argument","","",109,[[["genericargument",4]]]],[11,"visit_generic_param","","",109,[[["genericparam",4]]]],[11,"visit_generics","","",109,[[["generics",3]]]],[11,"visit_ident","","",109,[[["ident",3]]]],[11,"visit_index","","",109,[[["index",3]]]],[11,"visit_lifetime","","",109,[[["lifetime",3]]]],[11,"visit_lifetime_def","","",109,[[["lifetimedef",3]]]],[11,"visit_lit","","",109,[[["lit",4]]]],[11,"visit_lit_bool","","",109,[[["litbool",3]]]],[11,"visit_lit_byte","","",109,[[["litbyte",3]]]],[11,"visit_lit_byte_str","","",109,[[["litbytestr",3]]]],[11,"visit_lit_char","","",109,[[["litchar",3]]]],[11,"visit_lit_float","","",109,[[["litfloat",3]]]],[11,"visit_lit_int","","",109,[[["litint",3]]]],[11,"visit_lit_str","","",109,[[["litstr",3]]]],[11,"visit_macro","","",109,[[["macro",3]]]],[11,"visit_macro_delimiter","","",109,[[["macrodelimiter",4]]]],[11,"visit_member","","",109,[[["member",4]]]],[11,"visit_meta","","",109,[[["meta",4]]]],[11,"visit_meta_list","","",109,[[["metalist",3]]]],[11,"visit_meta_name_value","","",109,[[["metanamevalue",3]]]],[11,"visit_nested_meta","","",109,[[["nestedmeta",4]]]],[11,"visit_parenthesized_generic_arguments","","",109,[[["parenthesizedgenericarguments",3]]]],[11,"visit_path","","",109,[[["path",3]]]],[11,"visit_path_arguments","","",109,[[["patharguments",4]]]],[11,"visit_path_segment","","",109,[[["pathsegment",3]]]],[11,"visit_predicate_eq","","",109,[[["predicateeq",3]]]],[11,"visit_predicate_lifetime","","",109,[[["predicatelifetime",3]]]],[11,"visit_predicate_type","","",109,[[["predicatetype",3]]]],[11,"visit_qself","","",109,[[["qself",3]]]],[11,"visit_return_type","","",109,[[["returntype",4]]]],[11,"visit_span","","",109,[[["span",3]]]],[11,"visit_trait_bound","","",109,[[["traitbound",3]]]],[11,"visit_trait_bound_modifier","","",109,[[["traitboundmodifier",4]]]],[11,"visit_type","","",109,[[["type",4]]]],[11,"visit_type_array","","",109,[[["typearray",3]]]],[11,"visit_type_bare_fn","","",109,[[["typebarefn",3]]]],[11,"visit_type_group","","",109,[[["typegroup",3]]]],[11,"visit_type_impl_trait","","",109,[[["typeimpltrait",3]]]],[11,"visit_type_infer","","",109,[[["typeinfer",3]]]],[11,"visit_type_macro","","",109,[[["typemacro",3]]]],[11,"visit_type_never","","",109,[[["typenever",3]]]],[11,"visit_type_param","","",109,[[["typeparam",3]]]],[11,"visit_type_param_bound","","",109,[[["typeparambound",4]]]],[11,"visit_type_paren","","",109,[[["typeparen",3]]]],[11,"visit_type_path","","",109,[[["typepath",3]]]],[11,"visit_type_ptr","","",109,[[["typeptr",3]]]],[11,"visit_type_reference","","",109,[[["typereference",3]]]],[11,"visit_type_slice","","",109,[[["typeslice",3]]]],[11,"visit_type_trait_object","","",109,[[["typetraitobject",3]]]],[11,"visit_type_tuple","","",109,[[["typetuple",3]]]],[11,"visit_un_op","","",109,[[["unop",4]]]],[11,"visit_variadic","","",109,[[["variadic",3]]]],[11,"visit_variant","","",109,[[["variant",3]]]],[11,"visit_vis_crate","","",109,[[["viscrate",3]]]],[11,"visit_vis_public","","",109,[[["vispublic",3]]]],[11,"visit_vis_restricted","","",109,[[["visrestricted",3]]]],[11,"visit_visibility","","",109,[[["visibility",4]]]],[11,"visit_where_clause","","",109,[[["whereclause",3]]]],[11,"visit_where_predicate","","",109,[[["wherepredicate",4]]]],[11,"peek","syn::parse","Looks at the next token in the parse stream to determine …",244,[[["peek",8]]]],[11,"error","","Triggers an error at the current position of the parse …",244,[[],["error",3]]]],"p":[[3,"Underscore"],[3,"Abstract"],[3,"As"],[3,"Async"],[3,"Auto"],[3,"Await"],[3,"Become"],[3,"Box"],[3,"Break"],[3,"Const"],[3,"Continue"],[3,"Crate"],[3,"Default"],[3,"Do"],[3,"Dyn"],[3,"Else"],[3,"Enum"],[3,"Extern"],[3,"Final"],[3,"Fn"],[3,"For"],[3,"If"],[3,"Impl"],[3,"In"],[3,"Let"],[3,"Loop"],[3,"Macro"],[3,"Match"],[3,"Mod"],[3,"Move"],[3,"Mut"],[3,"Override"],[3,"Priv"],[3,"Pub"],[3,"Ref"],[3,"Return"],[3,"SelfType"],[3,"SelfValue"],[3,"Static"],[3,"Struct"],[3,"Super"],[3,"Trait"],[3,"Try"],[3,"Type"],[3,"Typeof"],[3,"Union"],[3,"Unsafe"],[3,"Unsized"],[3,"Use"],[3,"Virtual"],[3,"Where"],[3,"While"],[3,"Yield"],[3,"Add"],[3,"AddEq"],[3,"And"],[3,"AndAnd"],[3,"AndEq"],[3,"At"],[3,"Bang"],[3,"Caret"],[3,"CaretEq"],[3,"Colon"],[3,"Colon2"],[3,"Comma"],[3,"Div"],[3,"DivEq"],[3,"Dollar"],[3,"Dot"],[3,"Dot2"],[3,"Dot3"],[3,"DotDotEq"],[3,"Eq"],[3,"EqEq"],[3,"Ge"],[3,"Gt"],[3,"Le"],[3,"Lt"],[3,"MulEq"],[3,"Ne"],[3,"Or"],[3,"OrEq"],[3,"OrOr"],[3,"Pound"],[3,"Question"],[3,"RArrow"],[3,"LArrow"],[3,"Rem"],[3,"RemEq"],[3,"FatArrow"],[3,"Semi"],[3,"Shl"],[3,"ShlEq"],[3,"Shr"],[3,"ShrEq"],[3,"Star"],[3,"Sub"],[3,"SubEq"],[3,"Tilde"],[3,"Brace"],[3,"Bracket"],[3,"Paren"],[3,"Group"],[3,"TokenBuffer"],[3,"Cursor"],[8,"IdentExt"],[3,"Punctuated"],[4,"Pair"],[8,"Spanned"],[8,"Visit"],[8,"Speculative"],[8,"Parse"],[3,"StepCursor"],[3,"ParseBuffer"],[8,"Parser"],[3,"Error"],[4,"AttrStyle"],[3,"Attribute"],[4,"Meta"],[3,"MetaList"],[3,"MetaNameValue"],[4,"NestedMeta"],[3,"Field"],[4,"Fields"],[3,"FieldsNamed"],[3,"FieldsUnnamed"],[3,"Variant"],[3,"VisCrate"],[3,"VisPublic"],[3,"VisRestricted"],[4,"Visibility"],[4,"Expr"],[3,"ExprBinary"],[3,"ExprCall"],[3,"ExprCast"],[3,"ExprField"],[3,"ExprIndex"],[3,"ExprLit"],[3,"ExprParen"],[3,"ExprPath"],[3,"ExprUnary"],[3,"Index"],[4,"Member"],[3,"BoundLifetimes"],[3,"ConstParam"],[4,"GenericParam"],[3,"Generics"],[3,"LifetimeDef"],[3,"PredicateEq"],[3,"PredicateLifetime"],[3,"PredicateType"],[3,"TraitBound"],[4,"TraitBoundModifier"],[3,"TypeParam"],[4,"TypeParamBound"],[3,"WhereClause"],[4,"WherePredicate"],[3,"Lifetime"],[4,"Lit"],[3,"LitBool"],[4,"StrStyle"],[3,"Macro"],[4,"MacroDelimiter"],[4,"Data"],[3,"DataEnum"],[3,"DataStruct"],[3,"DataUnion"],[3,"DeriveInput"],[4,"BinOp"],[4,"UnOp"],[3,"Abi"],[3,"BareFnArg"],[4,"ReturnType"],[4,"Type"],[3,"TypeArray"],[3,"TypeBareFn"],[3,"TypeGroup"],[3,"TypeImplTrait"],[3,"TypeInfer"],[3,"TypeMacro"],[3,"TypeNever"],[3,"TypeParen"],[3,"TypePath"],[3,"TypePtr"],[3,"TypeReference"],[3,"TypeSlice"],[3,"TypeTraitObject"],[3,"TypeTuple"],[3,"Variadic"],[3,"AngleBracketedGenericArguments"],[3,"Binding"],[3,"Constraint"],[4,"GenericArgument"],[3,"ParenthesizedGenericArguments"],[3,"Path"],[4,"PathArguments"],[3,"PathSegment"],[3,"QSelf"],[3,"Ident"],[3,"ExprArray"],[3,"ExprAssign"],[3,"ExprAssignOp"],[3,"ExprAsync"],[3,"ExprAwait"],[3,"ExprBlock"],[3,"ExprBox"],[3,"ExprBreak"],[3,"ExprClosure"],[3,"ExprContinue"],[3,"ExprForLoop"],[3,"ExprGroup"],[3,"ExprIf"],[3,"ExprLet"],[3,"ExprLoop"],[3,"ExprMacro"],[3,"ExprMatch"],[3,"ExprMethodCall"],[3,"ExprRange"],[3,"ExprReference"],[3,"ExprRepeat"],[3,"ExprReturn"],[3,"ExprStruct"],[3,"ExprTry"],[3,"ExprTryBlock"],[3,"ExprTuple"],[3,"ExprType"],[3,"ExprUnsafe"],[3,"ExprWhile"],[3,"ExprYield"],[3,"ImplGenerics"],[3,"TypeGenerics"],[3,"Turbofish"],[3,"LitStr"],[3,"LitByteStr"],[3,"LitByte"],[3,"LitChar"],[3,"LitInt"],[3,"LitFloat"],[3,"Pairs"],[3,"PairsMut"],[3,"IntoPairs"],[3,"IntoIter"],[3,"Iter"],[3,"IterMut"],[3,"Lookahead1"],[3,"Nothing"]]},\ -"synstructure":{"doc":"This crate provides helper types for matching against …","i":[[4,"AddBounds","synstructure","Changes how bounds are added",null,null],[13,"Both","","Add for fields and generics",0,null],[13,"Fields","","Fields only",0,null],[13,"Generics","","Generics only",0,null],[13,"None","","None",0,null],[4,"BindStyle","","The type of binding to use when generating a pattern.",null,null],[13,"Move","","x",1,null],[13,"MoveMut","","mut x",1,null],[13,"Ref","","ref x",1,null],[13,"RefMut","","ref mut x",1,null],[3,"BindingInfo","","Information about a specific binding. This contains both …",null,null],[12,"binding","","The name which this BindingInfo will bind to.",2,null],[12,"style","","The type of binding which this BindingInfo will create.",2,null],[11,"ast","","Returns a reference to the underlying syn AST node which …",2,[[],["field",3]]],[11,"pat","","Generates the pattern fragment for this field binding.",2,[[],["tokenstream",3]]],[11,"referenced_ty_params","","Returns a list of the type parameters which are …",2,[[],[["ident",3],["vec",3]]]],[3,"VariantAst","","This type is similar to syn\'s Variant type, however each …",null,null],[12,"attrs","","",3,null],[12,"ident","","",3,null],[12,"fields","","",3,null],[12,"discriminant","","",3,null],[3,"VariantInfo","","A wrapper around a syn::DeriveInput\'s variant which …",null,null],[12,"prefix","","",4,null],[11,"bindings","","Returns a slice of the bindings in this Variant.",4,[[]]],[11,"bindings_mut","","Returns a mut slice of the bindings in this Variant.",4,[[]]],[11,"ast","","Returns a VariantAst object which contains references to …",4,[[],["variantast",3]]],[11,"omitted_bindings","","True if any bindings were omitted due to a filter call.",4,[[]]],[11,"pat","","Generates the match-arm pattern which could be used to …",4,[[],["tokenstream",3]]],[11,"construct","","Generates the token stream required to construct the …",4,[[],["tokenstream",3]]],[11,"each","","Runs the passed-in function once for each bound field, …",4,[[],["tokenstream",3]]],[11,"fold","","Runs the passed-in function once for each bound field, …",4,[[],["tokenstream",3]]],[11,"filter","","Filter the bindings created by this Variant object. This …",4,[[]]],[11,"remove_binding","","Remove the binding at the given index.",4,[[]]],[11,"bind_with","","Updates the BindStyle for each of the passed-in fields by …",4,[[]]],[11,"binding_name","","Updates the binding name for each fo the passed-in fields …",4,[[]]],[11,"referenced_ty_params","","Returns a list of the type parameters which are …",4,[[],[["ident",3],["vec",3]]]],[3,"Structure","","A wrapper around a syn::DeriveInput which provides …",null,null],[11,"new","","Create a new Structure with the variants and fields from …",5,[[["deriveinput",3]]]],[11,"try_new","","Create a new Structure with the variants and fields from …",5,[[["deriveinput",3]],["result",6]]],[11,"variants","","Returns a slice of the variants in this Structure.",5,[[]]],[11,"variants_mut","","Returns a mut slice of the variants in this Structure.",5,[[]]],[11,"ast","","Returns a reference to the underlying syn AST node which …",5,[[],["deriveinput",3]]],[11,"omitted_variants","","True if any variants were omitted due to a filter_variants…",5,[[]]],[11,"each","","Runs the passed-in function once for each bound field, …",5,[[],["tokenstream",3]]],[11,"fold","","Runs the passed-in function once for each bound field, …",5,[[],["tokenstream",3]]],[11,"each_variant","","Runs the passed-in function once for each variant, …",5,[[],["tokenstream",3]]],[11,"filter","","Filter the bindings created by this Structure object. …",5,[[]]],[11,"add_where_predicate","","Specify additional where predicate bounds which should be …",5,[[["wherepredicate",4]]]],[11,"add_bounds","","Specify which bounds should be generated by …",5,[[["addbounds",4]]]],[11,"filter_variants","","Filter the variants matched by this Structure object. …",5,[[]]],[11,"remove_variant","","Remove the variant at the given index.",5,[[]]],[11,"bind_with","","Updates the BindStyle for each of the passed-in fields by …",5,[[]]],[11,"binding_name","","Updates the binding name for each fo the passed-in fields …",5,[[]]],[11,"referenced_ty_params","","Returns a list of the type parameters which are refrenced …",5,[[],[["ident",3],["vec",3]]]],[11,"add_impl_generic","","Adds an impl<> generic parameter. This can be used when …",5,[[["genericparam",4]]]],[11,"add_trait_bounds","","Add trait bounds for a trait with the given path for each …",5,[[["traitbound",3],["option",4],["addbounds",4]]]],[11,"underscore_const","","Configure whether to use const _ instead of a generated …",5,[[]]],[11,"bound_impl","","NOTE: This methods\' features are superceded by …",5,[[["totokens",8]],["tokenstream",3]]],[11,"unsafe_bound_impl","","NOTE: This methods\' features are superceded by …",5,[[["totokens",8]],["tokenstream",3]]],[11,"unbound_impl","","NOTE: This methods\' features are superceded by …",5,[[["totokens",8]],["tokenstream",3]]],[11,"unsafe_unbound_impl","","NOTE: This methods\' features are superceded by …",5,[[["totokens",8]],["tokenstream",3]]],[11,"gen_impl","","Generate an impl block for the given struct. This impl …",5,[[["tokenstream",3]],["tokenstream",3]]],[5,"unpretty_print","","Dumps an unpretty version of a tokenstream. Takes any …",null,[[["display",8]],["string",3]]],[8,"MacroResult","","Helper trait describing values which may be returned by …",null,null],[10,"into_result","","Convert this result into a Result for further processing …",6,[[],[["tokenstream",3],["result",6]]]],[11,"into_stream","","Convert this result into a proc_macro::TokenStream, ready …",6,[[],["tokenstream",3]]],[14,"decl_derive","","The decl_derive! macro declares a custom derive wrapper. …",null,null],[14,"decl_attribute","","The decl_attribute! macro declares a custom attribute …",null,null],[14,"test_derive","","Run a test on a custom derive. This macro expands both …",null,null],[11,"from","","",0,[[]]],[11,"into","","",0,[[]]],[11,"to_owned","","",0,[[]]],[11,"clone_into","","",0,[[]]],[11,"borrow","","",0,[[]]],[11,"borrow_mut","","",0,[[]]],[11,"try_from","","",0,[[],["result",4]]],[11,"try_into","","",0,[[],["result",4]]],[11,"type_id","","",0,[[],["typeid",3]]],[11,"from","","",1,[[]]],[11,"into","","",1,[[]]],[11,"to_owned","","",1,[[]]],[11,"clone_into","","",1,[[]]],[11,"borrow","","",1,[[]]],[11,"borrow_mut","","",1,[[]]],[11,"try_from","","",1,[[],["result",4]]],[11,"try_into","","",1,[[],["result",4]]],[11,"type_id","","",1,[[],["typeid",3]]],[11,"span","","",1,[[],["span",3]]],[11,"from","","",2,[[]]],[11,"into","","",2,[[]]],[11,"to_owned","","",2,[[]]],[11,"clone_into","","",2,[[]]],[11,"borrow","","",2,[[]]],[11,"borrow_mut","","",2,[[]]],[11,"try_from","","",2,[[],["result",4]]],[11,"try_into","","",2,[[],["result",4]]],[11,"type_id","","",2,[[],["typeid",3]]],[11,"span","","",2,[[],["span",3]]],[11,"from","","",3,[[]]],[11,"into","","",3,[[]]],[11,"to_owned","","",3,[[]]],[11,"clone_into","","",3,[[]]],[11,"borrow","","",3,[[]]],[11,"borrow_mut","","",3,[[]]],[11,"try_from","","",3,[[],["result",4]]],[11,"try_into","","",3,[[],["result",4]]],[11,"type_id","","",3,[[],["typeid",3]]],[11,"from","","",4,[[]]],[11,"into","","",4,[[]]],[11,"to_owned","","",4,[[]]],[11,"clone_into","","",4,[[]]],[11,"borrow","","",4,[[]]],[11,"borrow_mut","","",4,[[]]],[11,"try_from","","",4,[[],["result",4]]],[11,"try_into","","",4,[[],["result",4]]],[11,"type_id","","",4,[[],["typeid",3]]],[11,"from","","",5,[[]]],[11,"into","","",5,[[]]],[11,"to_owned","","",5,[[]]],[11,"clone_into","","",5,[[]]],[11,"borrow","","",5,[[]]],[11,"borrow_mut","","",5,[[]]],[11,"try_from","","",5,[[],["result",4]]],[11,"try_into","","",5,[[],["result",4]]],[11,"type_id","","",5,[[],["typeid",3]]],[11,"clone","","",0,[[],["addbounds",4]]],[11,"clone","","",1,[[],["bindstyle",4]]],[11,"clone","","",2,[[],["bindinginfo",3]]],[11,"clone","","",3,[[],["variantast",3]]],[11,"clone","","",4,[[],["variantinfo",3]]],[11,"clone","","",5,[[],["structure",3]]],[11,"eq","","",0,[[["addbounds",4]]]],[11,"eq","","",1,[[["bindstyle",4]]]],[11,"eq","","",2,[[["bindinginfo",3]]]],[11,"ne","","",2,[[["bindinginfo",3]]]],[11,"eq","","",3,[[["variantast",3]]]],[11,"ne","","",3,[[["variantast",3]]]],[11,"eq","","",4,[[["variantinfo",3]]]],[11,"ne","","",4,[[["variantinfo",3]]]],[11,"eq","","",5,[[["structure",3]]]],[11,"ne","","",5,[[["structure",3]]]],[11,"fmt","","",0,[[["formatter",3]],["result",6]]],[11,"fmt","","",1,[[["formatter",3]],["result",6]]],[11,"fmt","","",2,[[["formatter",3]],["result",6]]],[11,"fmt","","",3,[[["formatter",3]],["result",6]]],[11,"fmt","","",4,[[["formatter",3]],["result",6]]],[11,"fmt","","",5,[[["formatter",3]],["result",6]]],[11,"hash","","",0,[[]]],[11,"hash","","",1,[[]]],[11,"hash","","",2,[[]]],[11,"hash","","",3,[[]]],[11,"hash","","",4,[[]]],[11,"hash","","",5,[[]]],[11,"to_tokens","","",1,[[["tokenstream",3]]]],[11,"to_tokens","","",2,[[["tokenstream",3]]]]],"p":[[4,"AddBounds"],[4,"BindStyle"],[3,"BindingInfo"],[3,"VariantAst"],[3,"VariantInfo"],[3,"Structure"],[8,"MacroResult"]]},\ -"unicode_xid":{"doc":"Determine if a char is a valid identifier for a parser …","i":[[17,"UNICODE_VERSION","unicode_xid","The version of Unicode that this version of unicode-xid …",null,null],[8,"UnicodeXID","","Methods for determining if a character is a valid …",null,null],[10,"is_xid_start","","Returns whether the specified character satisfies the …",0,[[]]],[10,"is_xid_continue","","Returns whether the specified char satisfies the …",0,[[]]]],"p":[[8,"UnicodeXID"]]}\ +"cfg_if":{"doc":"A macro for defining #[cfg] if-else statements.","t":[14],"n":["cfg_if"],"q":["cfg_if"],"d":["The main macro provided by this crate. See crate …"],"i":[0],"f":[null],"p":[]},\ +"delog":{"doc":"Compile-time configurable deferred logging (for printf()…","t":[0,8,18,3,8,18,3,12,5,0,5,5,3,5,3,4,13,13,13,13,13,4,13,13,13,13,13,13,3,8,10,10,10,10,11,3,12,12,12,12,12,8,10,10,10,10,10,8,10,8,11,5,5,5,8,10,8,10,5,14,14,14,14,14,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11],"n":["hex","Unsigned","N","U1","Separator","SEPARATOR","HexStr","value","HexStr","render","render_arguments","render_record","DefaultRenderer","default","RipgrepRenderer","Level","Error","Warn","Info","Debug","Trace","LevelFilter","Off","Error","Warn","Info","Debug","Trace","Record","Delogger","buffer","claimed","flush","render","capacity","Statistics","attempts","successes","flushes","read","written","State","attempts","successes","flushes","read","written","TryLog","try_log","TryLogWithStatistics","statistics","dequeue","enqueue","try_enqueue","Flusher","flush","Renderer","render","logger","hex_str","hexstr","try_log","generate_macros","delog","borrow","borrow_mut","try_from","from","into","try_into","type_id","borrow","borrow_mut","try_from","from","into","try_into","type_id","borrow","borrow_mut","try_from","from","into","try_into","type_id","borrow","borrow_mut","try_from","from","into","try_into","type_id","borrow","borrow_mut","try_from","from","into","try_into","type_id","borrow","borrow_mut","try_from","from","into","try_into","type_id","borrow","borrow_mut","try_from","from","into","try_into","type_id","borrow","borrow_mut","try_from","from","into","try_into","type_id","eq","eq","eq","eq","fmt","fmt","fmt","from_str","from_str","fmt","fmt","clone","clone","clone","partial_cmp","lt","le","gt","ge","partial_cmp","lt","le","gt","ge","partial_cmp","lt","le","gt","ge","partial_cmp","lt","le","gt","ge","hash","hash","cmp","cmp","render","render","fmt","fmt","fmt","fmt","fmt","clone","clone","clone","capacity","statistics","max","to_level_filter","as_str","max","to_level","as_str","builder","args","metadata","level","target","module_path","module_path_static","file","file_static","line"],"q":["delog","delog::hex","","","","","","","","delog","delog::render","","","","","delog","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","delog::hex","","","","","","","","","","","","","","delog","","","","","","","delog::render","","","","","","","","","","","","","","delog","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","delog::render","","delog::hex","delog","delog::hex","","","delog","delog::render","","delog","","","","","","","","","","","","","","","","",""],"d":["Convenient Display and other traits for binary data.","A type that specifies an unsigned integer.","The actual number.","A type that represents the integer 1.","A type that specifies a separator str.","The actual separator str.","Zero-sized wrapper newtype, allowing grouping bytes in …","The value to be formatted.","Explicitly construct a newtype to format with.","The default, minimal renderer, and some helper functions.","For some reason, there seems to be no existing method to …","Render record, based on feature flags.","Renders just the record.args().","The default, minimal renderer.","Renders the record.args(), prefixed by level, target, and …","An enum representing the available verbosity levels of …","The “error” level.","The “warn” level.","The “info” level.","The “debug” level.","The “trace” level.","An enum representing the available verbosity level …","A level lower than all log levels.","Corresponds to the Error log level.","Corresponds to the Warn log level.","Corresponds to the Info log level.","Corresponds to the Debug log level.","Corresponds to the Trace log level.","The “payload” of a log message.","Semi-abstract characterization of the deferred loggers …","the underlying buffer","How many characters were claimed so far.","Call the flusher.","Actually render the arguments (via internal static …","Capacity of circular buffer.","Statistics on logger usage.","How often was one of the logging macros called.","How often was one of the logging macros called without …","How often was the flusher called.","How many bytes were flushed so far.","How many bytes were logged so far.","Trait for either state or statistics of loggers.","How often was one of the logging macros called.","How often was one of the logging macros called without …","How often was the flusher called.","How many bytes were flushed so far.","How many bytes were logged so far.","Fallible, panic-free version of the log::Log trait.","Fallible logging call (fails when buffer is full)","TryLog with some usage statistics on top.","Read out statistics on logger usage.","The core “read from circular buffer” method. Marked …","The core “write to circular buffer” method. Marked …","The fallible “write to circular buffer” method. …","A way to pass on logs, user supplied.","Implementor must handle passed log &str in some hopefully …","A way to format logs, user supplied.","Implementor must render record into buf, returning the …","Returns a reference to the logger (as TryLogWithStatistics…","Compactly format byte arrays and slices as hexadecimals.","More compactly format byte arrays and slices as …","Fallible (ungated) version of log!.","Generate logging macros that can be gated by library.","Generate a deferred logger with specified capacity and …","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","Capacity of circular buffer.","Read out statistics on logger usage.","Returns the most verbose logging level.","Converts the Level to the equivalent LevelFilter.","Returns the string representation of the Level.","Returns the most verbose logging level filter.","Converts self to the equivalent Level.","Returns the string representation of the LevelFilter.","Returns a new builder.","The message body.","Metadata about the log directive.","The verbosity level of the message.","The name of the target of the directive.","The module path of the message.","The module path of the message, if it is a \'static string.","The source file containing the message.","The module path of the message, if it is a \'static string.","The line containing the message."],"i":[0,0,1,0,0,2,0,3,0,0,0,0,0,0,0,0,4,4,4,4,4,0,5,5,5,5,5,5,0,0,6,6,6,6,6,0,7,7,7,7,7,0,8,8,8,8,8,0,9,0,10,0,0,0,0,11,0,12,0,0,0,0,0,0,13,13,13,13,13,13,13,3,3,3,3,3,3,3,7,7,7,7,7,7,7,14,14,14,14,14,14,14,15,15,15,15,15,15,15,4,4,4,4,4,4,4,5,5,5,5,5,5,5,16,16,16,16,16,16,16,5,4,4,5,16,4,5,4,5,4,5,5,16,4,5,5,5,5,5,4,4,4,4,4,4,4,4,4,4,5,5,5,5,5,4,5,5,4,14,15,3,7,3,3,3,7,14,15,6,10,4,4,4,5,5,5,16,16,16,16,16,16,16,16,16,16],"f":[null,null,null,null,null,null,null,null,[[],[["sized",8],["unsigned",8],["hexstr",3],["separator",8]]],null,[[["arguments",3]]],[[["record",3]]],null,[[],["defaultrenderer",3]],null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,[[]],[[],["atomicusize",3]],[[["str",15]]],[[["record",3]]],[[],["usize",15]],null,null,null,null,null,null,null,[[]],[[]],[[]],[[]],[[]],null,[[["record",3]],["result",4]],null,[[],["statistics",3]],[[],["str",15]],[[["record",3]]],[[["record",3]],["result",4]],null,[[["str",15]]],null,[[["record",3]]],[[],["option",4]],null,null,null,null,null,[[]],[[]],[[],["result",4]],[[]],[[]],[[],["result",4]],[[],["typeid",3]],[[]],[[]],[[],["result",4]],[[]],[[]],[[],["result",4]],[[],["typeid",3]],[[]],[[]],[[],["result",4]],[[]],[[]],[[],["result",4]],[[],["typeid",3]],[[]],[[]],[[],["result",4]],[[]],[[]],[[],["result",4]],[[],["typeid",3]],[[]],[[]],[[],["result",4]],[[]],[[]],[[],["result",4]],[[],["typeid",3]],[[]],[[]],[[],["result",4]],[[]],[[]],[[],["result",4]],[[],["typeid",3]],[[]],[[]],[[],["result",4]],[[]],[[]],[[],["result",4]],[[],["typeid",3]],[[]],[[]],[[],["result",4]],[[]],[[]],[[],["result",4]],[[],["typeid",3]],[[["level",4]],["bool",15]],[[["level",4]],["bool",15]],[[["levelfilter",4]],["bool",15]],[[["levelfilter",4]],["bool",15]],[[["formatter",3]],[["result",4],["error",3]]],[[["formatter",3]],[["result",4],["error",3]]],[[["formatter",3]],[["result",4],["error",3]]],[[["str",15]],[["level",4],["result",4]]],[[["str",15]],[["levelfilter",4],["result",4]]],[[["formatter",3]],[["result",4],["error",3]]],[[["formatter",3]],[["result",4],["error",3]]],[[],["levelfilter",4]],[[],["record",3]],[[],["level",4]],[[["level",4]],[["option",4],["ordering",4]]],[[["level",4]],["bool",15]],[[["level",4]],["bool",15]],[[["level",4]],["bool",15]],[[["level",4]],["bool",15]],[[["level",4]],[["option",4],["ordering",4]]],[[["level",4]],["bool",15]],[[["level",4]],["bool",15]],[[["level",4]],["bool",15]],[[["level",4]],["bool",15]],[[["levelfilter",4]],[["option",4],["ordering",4]]],[[["levelfilter",4]],["bool",15]],[[["levelfilter",4]],["bool",15]],[[["levelfilter",4]],["bool",15]],[[["levelfilter",4]],["bool",15]],[[["levelfilter",4]],[["option",4],["ordering",4]]],[[["levelfilter",4]],["bool",15]],[[["levelfilter",4]],["bool",15]],[[["levelfilter",4]],["bool",15]],[[["levelfilter",4]],["bool",15]],[[]],[[]],[[["levelfilter",4]],["ordering",4]],[[["level",4]],["ordering",4]],[[["record",3]]],[[["record",3]]],[[["formatter",3]],[["error",3],["result",4]]],[[["formatter",3]],["result",6]],[[["formatter",3]],[["error",3],["result",4]]],[[["formatter",3]],[["error",3],["result",4]]],[[["formatter",3]],[["error",3],["result",4]]],[[],["statistics",3]],[[],["defaultrenderer",3]],[[],["ripgreprenderer",3]],[[],["usize",15]],[[],["statistics",3]],[[],["level",4]],[[],["levelfilter",4]],[[],["str",15]],[[],["levelfilter",4]],[[],[["option",4],["level",4]]],[[],["str",15]],[[],["recordbuilder",3]],[[],["arguments",3]],[[],["metadata",3]],[[],["level",4]],[[],["str",15]],[[],[["option",4],["str",15]]],[[],[["option",4],["str",15]]],[[],[["option",4],["str",15]]],[[],[["option",4],["str",15]]],[[],[["u32",15],["option",4]]]],"p":[[8,"Unsigned"],[8,"Separator"],[3,"HexStr"],[4,"Level"],[4,"LevelFilter"],[8,"Delogger"],[3,"Statistics"],[8,"State"],[8,"TryLog"],[8,"TryLogWithStatistics"],[8,"Flusher"],[8,"Renderer"],[3,"U1"],[3,"DefaultRenderer"],[3,"RipgrepRenderer"],[3,"Record"]]},\ +"flexiber":{"doc":"flexiber","t":[24,24,3,3,3,4,13,13,12,13,12,13,13,12,13,13,13,12,12,13,13,12,12,13,12,12,13,6,3,3,3,4,13,13,13,13,3,12,12,12,8,10,11,11,6,3,8,10,8,10,11,8,10,10,11,8,10,14,14,14,14,14,14,14,14,14,14,14,14,14,14,14,14,14,14,14,14,14,14,14,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,18,18,18,18,18,18,18,18,18,18,18,18,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11],"n":["Decodable","Encodable","Decoder","Encoder","Error","ErrorKind","Failed","InvalidClass","value","InvalidTag","byte","InvalidLength","Length","tag","Overflow","Overlength","TrailingData","decoded","remaining","Truncated","Underlength","expected","actual","UnexpectedTag","expected","actual","UnsupportedTagSize","Result","Length","SimpleTag","Slice","Class","Universal","Application","Context","Private","Tag","class","constructed","number","TagLike","embedding","assert_eq","with_value","TaggedSlice","TaggedValue","Container","fields","Decodable","decode","from_bytes","Encodable","encoded_length","encode","encode_to_slice","Tagged","tag","try_debug","try_error","try_info","try_trace","try_warn","log","debug","error","info","trace","warn","log_now","debug_now","error_now","info_now","trace_now","warn_now","try_log_now","try_debug_now","try_error_now","try_info_now","try_trace_now","try_warn_now","borrow","borrow_mut","try_from","from","into","try_into","type_id","borrow","borrow_mut","try_from","from","into","try_into","type_id","borrow","borrow_mut","try_from","from","into","try_into","type_id","borrow","borrow_mut","try_from","from","into","try_into","type_id","borrow","borrow_mut","try_from","from","into","try_into","type_id","borrow","borrow_mut","try_from","from","into","try_into","type_id","borrow","borrow_mut","try_from","from","into","try_into","type_id","borrow","borrow_mut","try_from","from","into","try_into","type_id","borrow","borrow_mut","try_from","from","into","try_into","type_id","borrow","borrow_mut","try_from","from","into","try_into","type_id","embedding","embedding","decode","decode","decode","decode","encoded_length","encode","encoded_length","encode","encoded_length","encode","encoded_length","encode","encoded_length","encode","fmt","fmt","fmt","fmt","fmt","fmt","fmt","fmt","fmt","fmt","fmt","fmt","fmt","eq","ne","eq","ne","eq","ne","eq","ne","eq","ne","eq","eq","ne","eq","ne","cmp","partial_cmp","add","add","add","add","add","try_from","try_from","try_from","try_from","try_from","try_from","from","from","from","from","from","as_ref","clone","clone","clone","clone","clone","clone","clone","clone","default","new","decode","decode_tagged_value","decode_tagged_slice","error","is_failed","finish","is_finished","new","encode","error","is_failed","finish","encode_tagged_collection","encode_untagged_collection","new","kind","position","nested","at","zero","max","to_usize","new","as_bytes","length","is_empty","BOOLEAN","INTEGER","BIT_STRING","OCTET_STRING","NULL","OBJECT_IDENTIFIER","UTF8_STRING","PRINTABLE_STRING","UTC_TIME","GENERALIZED_TIME","SEQUENCE","SET","from","universal","application","context","private","constructed","assert_eq","with_value","new","tag","from","as_bytes","length","is_empty","decode_nested","from","as_bytes","length","is_empty","decode_nested","from_bytes","encode_to_slice"],"q":["flexiber","","","","","","","","flexiber::ErrorKind","flexiber","flexiber::ErrorKind","flexiber","","flexiber::ErrorKind","flexiber","","","flexiber::ErrorKind","","flexiber","","flexiber::ErrorKind","","flexiber","flexiber::ErrorKind","","flexiber","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","",""],"d":["Derive the Decodable trait on a struct.","Derive the Encodable trait on a struct.","BER-TLV decoder.","BER-TLV encoder.","Error type.","Error type.","Operation failed due to previous error","Class has more than 2 bytes","","Invalid tag","Raw byte value of the tag","Length greater than u16::MAX","Incorrect length for a given field","Tag type of the value being decoded","Integer overflow occurred (library bug!)","Message is longer than BER-TLV’s limits support","Undecoded trailing data at end of message","Length of the decoded data","Total length of the remaining data left in the buffer","Unexpected end-of-message/nested field when decoding","Encoded message is shorter than the expected length (i.e. …","Expected length","Actual length","Unexpected tag","Tag the decoder was expecting (if there is a single such …","Actual tag encountered in the message","Tag does not fit in 3 bytes","Result type.","BER-TLV-encoded length.","These are tags like in SIMPLE-TLV.","Slice of at most Length::max() bytes.","Class of BER tag.","","","","","The tag field consists of a single byte encoding a tag …","","","","This is the common trait that types to be used as tags …","To stick with one Error type, make sure the tag type can …","Assert that this [Tag] matches the provided expected tag.","Ergonomic way to get a TaggedValue for a given tag and …","Raw BER-TLV data object TaggedValue>.","BER-TLV data object.","Multiple encodables in a container.","Call the provided function with a slice of [Encodable] …","Decoding trait.","Attempt to decode this message using the provided decoder.","Parse Self from the provided byte slice.","Encoding trait.","Compute the length of this value in bytes when encoded as …","Encode this value as BER-TLV using the provided [Encoder].","Encode this value to the provided byte slice, returning a …","Types with an associated BER-TLV [Tag].","The tag","Fallible version of debug!.","Fallible version of error!.","Fallible version of info!.","Fallible version of trace!.","Fallible version of warn!.","Local version of log!.","Local version of debug!.","Local version of error!.","Local version of info!.","Local version of trace!.","Local version of warn!.","Immediate version of log!.","Immediate version of debug!.","Immediate version of error!.","Immediate version of info!.","Immediate version of trace!.","Immediate version of warn!.","Fallible immediate version of log!.","Fallible immediate version of debug!.","Fallible immediate version of error!.","Fallible immediate version of info!.","Fallible immediate version of trace!.","Fallible immediate version of warn!.","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","Create a new decoder for the given byte slice.","Decode a value which impls the [Decodable] trait.","Decode a TaggedValue with tag checked to be as expected, …","Decode a TaggedSlice with tag checked to be as expected, …","Return an error with the given [ErrorKind], annotating it …","Did the decoding operation fail due to an error?","Finish decoding, returning the given value if there is no …","Have we decoded all of the bytes in this [Decoder]?","Create a new encoder with the given byte slice as a …","Encode a value which impls the [Encodable] trait.","Return an error with the given [ErrorKind], annotating it …","Did the decoding operation fail due to an error?","Finish encoding to the buffer, returning a slice …","Encode a collection of values which impl the [Encodable] …","Encode a collection of values which impl the [Encodable] …","Create a new [Error]","Get the [ErrorKind] which occurred.","Get the position inside of the message where the error …","For errors occurring inside of a nested message, extend …","Annotate an [ErrorKind] with context about where it …","Return a length of 0.","Get the maximum length supported by BER-TLV: 65,535.","Convert length to usize.","Create a new [Slice], ensuring that the provided slice …","Borrow the inner byte slice","Get the [Length] of this [Slice]","Is this [Slice] empty?","","","","","","","","","","","","","","","","","","","Assert that this [Tag] matches the provided expected tag.","Ergonomic way to get a TaggedValue for a given tag and …","","","Create a new tagged slice, checking lengths.","Borrow the inner byte slice.","Get the length of the inner byte slice.","Is the inner byte slice empty?","Decode nested values, creating a new [Decoder] for the …","Create a new tagged slice, checking lengths.","Borrow the inner byte slice.","Get the length of the inner byte slice.","Is the inner byte slice empty?","Decode nested values, creating a new [Decoder] for the …","Parse Self from the provided byte slice.","Encode this value to the provided byte slice, returning a …"],"i":[0,0,0,0,0,0,1,1,2,1,3,1,1,4,1,1,1,5,5,1,1,6,6,1,7,7,1,0,0,0,0,0,8,8,8,8,0,9,9,9,0,10,10,10,0,0,0,11,0,12,12,0,13,13,13,0,14,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,15,15,15,15,15,15,15,16,16,16,16,16,16,16,17,17,17,17,17,17,17,1,1,1,1,1,1,1,18,18,18,18,18,18,18,19,19,19,19,19,19,19,20,20,20,20,20,20,20,8,8,8,8,8,8,8,9,9,9,9,9,9,9,21,21,21,21,21,21,21,19,9,18,19,9,22,18,18,19,19,9,9,21,21,22,22,15,16,17,1,18,20,8,9,21,17,1,18,9,17,17,1,1,18,18,19,19,20,20,8,9,9,21,21,18,18,18,18,18,18,23,18,18,19,8,9,9,15,17,17,18,18,20,17,1,18,19,20,8,9,21,18,15,15,15,15,15,15,15,15,16,16,16,16,16,16,16,17,17,17,17,1,18,18,18,20,20,20,20,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,10,10,21,21,21,21,21,21,21,22,22,22,22,22,12,13],"f":[null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,[[],["tag",3]],[[],["result",6]],[[],["taggedvalue",3]],null,null,null,[[],["result",6]],null,[[["decoder",3]],["result",6]],[[],["result",6]],null,[[],[["length",3],["result",6]]],[[["encoder",3]],["result",6]],[[],["result",6]],null,[[],["tag",3]],null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,[[]],[[]],[[],["result",4]],[[]],[[]],[[],["result",4]],[[],["typeid",3]],[[]],[[]],[[],["result",4]],[[]],[[]],[[],["result",4]],[[],["typeid",3]],[[]],[[]],[[],["result",4]],[[]],[[]],[[],["result",4]],[[],["typeid",3]],[[]],[[]],[[],["result",4]],[[]],[[]],[[],["result",4]],[[],["typeid",3]],[[]],[[]],[[],["result",4]],[[]],[[]],[[],["result",4]],[[],["typeid",3]],[[]],[[]],[[],["result",4]],[[]],[[]],[[],["result",4]],[[],["typeid",3]],[[]],[[]],[[],["result",4]],[[]],[[]],[[],["result",4]],[[],["typeid",3]],[[]],[[]],[[],["result",4]],[[]],[[]],[[],["result",4]],[[],["typeid",3]],[[]],[[]],[[],["result",4]],[[]],[[]],[[],["result",4]],[[],["typeid",3]],[[]],[[]],[[],["result",4]],[[]],[[]],[[],["result",4]],[[],["typeid",3]],[[],["tag",3]],[[],["tag",3]],[[["decoder",3]],[["length",3],["result",6]]],[[["decoder",3]],["result",6]],[[["decoder",3]],["result",6]],[[["decoder",3]],["result",6]],[[],[["length",3],["result",6]]],[[["encoder",3]],["result",6]],[[],[["length",3],["result",6]]],[[["encoder",3]],["result",6]],[[],[["length",3],["result",6]]],[[["encoder",3]],["result",6]],[[],[["length",3],["result",6]]],[[["encoder",3]],["result",6]],[[],[["length",3],["result",6]]],[[["encoder",3]],["result",6]],[[["formatter",3]],["result",6]],[[["formatter",3]],["result",6]],[[["formatter",3]],["result",6]],[[["formatter",3]],["result",6]],[[["formatter",3]],["result",6]],[[["formatter",3]],["result",6]],[[["formatter",3]],["result",6]],[[["formatter",3]],["result",6]],[[["formatter",3]],["result",6]],[[["formatter",3]],["result",6]],[[["formatter",3]],["result",6]],[[["formatter",3]],["result",6]],[[["formatter",3]],["result",6]],[[["error",3]],["bool",15]],[[["error",3]],["bool",15]],[[["errorkind",4]],["bool",15]],[[["errorkind",4]],["bool",15]],[[["length",3]],["bool",15]],[[["length",3]],["bool",15]],[[["simpletag",3]],["bool",15]],[[["simpletag",3]],["bool",15]],[[["slice",3]],["bool",15]],[[["slice",3]],["bool",15]],[[["class",4]],["bool",15]],[[["tag",3]],["bool",15]],[[["tag",3]],["bool",15]],[[["taggedvalue",3]],["bool",15]],[[["taggedvalue",3]],["bool",15]],[[["length",3]],["ordering",4]],[[["length",3]],[["ordering",4],["option",4]]],[[],["result",6]],[[["u8",15]],["result",6]],[[["u16",15]],["result",6]],[[["usize",15]],["result",6]],[[["length",3]]],[[],[["length",3],["result",6]]],[[["usize",15]],[["length",3],["result",6]]],[[["u8",15]],["result",6]],[[["u8",15]],["result",6]],[[],["result",6]],[[["u8",15]],["result",6]],[[],["decoder",3]],[[["errorkind",4]],["error",3]],[[["infallible",4]],["error",3]],[[["u8",15]],["length",3]],[[["u16",15]],["length",3]],[[]],[[],["error",3]],[[],["errorkind",4]],[[],["length",3]],[[],["simpletag",3]],[[],["slice",3]],[[],["class",4]],[[],["tag",3]],[[],["taggedvalue",3]],[[],["length",3]],[[]],[[],[["result",6],["decodable",8]]],[[["decodable",8],["taglike",8]],[["decodable",8],["result",6]]],[[["decodable",8],["taglike",8]],["result",6]],[[["errorkind",4]],["result",6]],[[],["bool",15]],[[],["result",6]],[[],["bool",15]],[[]],[[],["result",6]],[[["errorkind",4]],["result",6]],[[],["bool",15]],[[],["result",6]],[[["tag",3]],["result",6]],[[],["result",6]],[[["length",3],["errorkind",4]],["error",3]],[[],["errorkind",4]],[[],[["option",4],["length",3]]],[[["length",3]]],[[["length",3]],["error",3]],[[]],[[],["usize",15]],[[],["usize",15]],[[],["result",6]],[[]],[[],["length",3]],[[],["bool",15]],null,null,null,null,null,null,null,null,null,null,null,null,[[["bool",15],["u16",15],["class",4]]],[[["u16",15]]],[[["u16",15]]],[[["u16",15]]],[[["u16",15]]],[[]],[[],["result",6]],[[],["taggedvalue",3]],[[]],[[]],[[],["result",6]],[[]],[[],["length",3]],[[],["bool",15]],[[],["result",6]],[[],["result",6]],[[]],[[],["length",3]],[[],["bool",15]],[[],["result",6]],[[],["result",6]],[[],["result",6]]],"p":[[4,"ErrorKind"],[13,"InvalidClass"],[13,"InvalidTag"],[13,"Length"],[13,"TrailingData"],[13,"Underlength"],[13,"UnexpectedTag"],[4,"Class"],[3,"Tag"],[8,"TagLike"],[8,"Container"],[8,"Decodable"],[8,"Encodable"],[8,"Tagged"],[3,"Decoder"],[3,"Encoder"],[3,"Error"],[3,"Length"],[3,"SimpleTag"],[3,"Slice"],[3,"TaggedValue"],[6,"TaggedSlice"],[6,"Result"]]},\ +"flexiber_derive":{"doc":"Custom derive support for the flexiber crate","t":[24,24],"n":["Decodable","Encodable"],"q":["flexiber_derive",""],"d":["Derive the Decodable trait on a struct.","Derive the Encodable trait on a struct."],"i":[0,0],"f":[null,null],"p":[]},\ +"log":{"doc":"A lightweight logging facade.","t":[4,13,13,13,13,13,11,11,11,4,13,13,13,13,13,13,11,11,11,3,11,11,11,11,11,11,11,11,11,11,3,11,11,11,11,11,11,11,11,11,11,11,3,11,11,11,3,11,11,11,11,8,10,10,10,5,5,5,5,3,3,5,17,14,14,14,14,14,14,14,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11],"n":["Level","Error","Warn","Info","Debug","Trace","max","to_level_filter","as_str","LevelFilter","Off","Error","Warn","Info","Debug","Trace","max","to_level","as_str","Record","builder","args","metadata","level","target","module_path","module_path_static","file","file_static","line","RecordBuilder","new","args","metadata","level","target","module_path","module_path_static","file","file_static","line","build","Metadata","builder","level","target","MetadataBuilder","new","level","target","build","Log","enabled","log","flush","set_max_level","max_level","set_logger","set_logger_racy","SetLoggerError","ParseLevelError","logger","STATIC_MAX_LEVEL","log","error","warn","info","debug","trace","log_enabled","borrow","borrow_mut","try_from","from","into","try_into","type_id","borrow","borrow_mut","try_from","from","into","try_into","type_id","borrow","borrow_mut","try_from","from","into","try_into","type_id","borrow","borrow_mut","try_from","from","into","try_into","type_id","borrow","borrow_mut","try_from","from","into","try_into","type_id","borrow","borrow_mut","try_from","from","into","try_into","type_id","borrow","borrow_mut","try_from","from","into","try_into","type_id","borrow","borrow_mut","try_from","from","into","try_into","type_id","fmt","fmt","fmt","fmt","fmt","fmt","fmt","fmt","fmt","fmt","fmt","fmt","eq","eq","eq","eq","eq","ne","eq","ne","eq","ne","cmp","cmp","cmp","cmp","partial_cmp","lt","le","gt","ge","partial_cmp","lt","le","gt","ge","partial_cmp","lt","le","gt","ge","partial_cmp","lt","le","gt","ge","partial_cmp","partial_cmp","hash","hash","hash","hash","from_str","from_str","clone","clone","clone","clone"],"q":["log","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","",""],"d":["An enum representing the available verbosity levels of …","The “error” level.","The “warn” level.","The “info” level.","The “debug” level.","The “trace” level.","Returns the most verbose logging level.","Converts the Level to the equivalent LevelFilter.","Returns the string representation of the Level.","An enum representing the available verbosity level …","A level lower than all log levels.","Corresponds to the Error log level.","Corresponds to the Warn log level.","Corresponds to the Info log level.","Corresponds to the Debug log level.","Corresponds to the Trace log level.","Returns the most verbose logging level filter.","Converts self to the equivalent Level.","Returns the string representation of the LevelFilter.","The “payload” of a log message.","Returns a new builder.","The message body.","Metadata about the log directive.","The verbosity level of the message.","The name of the target of the directive.","The module path of the message.","The module path of the message, if it is a \'static string.","The source file containing the message.","The module path of the message, if it is a \'static string.","The line containing the message.","Builder for Record.","Construct new RecordBuilder.","Set args.","Set metadata. Construct a Metadata object with …","Set Metadata::level.","Set Metadata::target","Set module_path","Set module_path to a \'static string","Set file","Set file to a \'static string.","Set line","Invoke the builder and return a Record","Metadata about a log message.","Returns a new builder.","The verbosity level of the message.","The name of the target of the directive.","Builder for Metadata.","Construct a new MetadataBuilder.","Setter for level.","Setter for target.","Returns a Metadata object.","A trait encapsulating the operations required of a logger.","Determines if a log message with the specified metadata …","Logs the Record.","Flushes any buffered records.","Sets the global maximum log level.","Returns the current maximum log level.","Sets the global logger to a &\'static Log.","A thread-unsafe version of set_logger.","The type returned by set_logger if set_logger has already …","The type returned by from_str when the string doesn’t …","Returns a reference to the logger.","The statically resolved maximum log level.","The standard logging macro.","Logs a message at the error level.","Logs a message at the warn level.","Logs a message at the info level.","Logs a message at the debug level.","Logs a message at the trace level.","Determines if a message logged at the specified level in …","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","",""],"i":[0,1,1,1,1,1,1,1,1,0,2,2,2,2,2,2,2,2,2,0,3,3,3,3,3,3,3,3,3,3,0,4,4,4,4,4,4,4,4,4,4,4,0,5,5,5,0,6,6,6,6,0,7,7,7,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,2,2,2,2,2,2,2,3,3,3,3,3,3,3,4,4,4,4,4,4,4,5,5,5,5,5,5,5,6,6,6,6,6,6,6,8,8,8,8,8,8,8,9,9,9,9,9,9,9,1,2,3,4,5,6,8,9,1,2,8,9,1,1,2,2,5,5,6,6,9,9,1,2,5,6,1,1,1,1,1,1,1,1,1,1,2,2,2,2,2,2,2,2,2,2,5,6,1,2,5,6,1,2,1,2,3,5],"f":[null,null,null,null,null,null,[[],["level",4]],[[],["levelfilter",4]],[[],["str",15]],null,null,null,null,null,null,null,[[],["levelfilter",4]],[[],[["level",4],["option",4]]],[[],["str",15]],null,[[],["recordbuilder",3]],[[],["arguments",3]],[[],["metadata",3]],[[],["level",4]],[[],["str",15]],[[],[["option",4],["str",15]]],[[],[["str",15],["option",4]]],[[],[["option",4],["str",15]]],[[],[["str",15],["option",4]]],[[],[["u32",15],["option",4]]],null,[[],["recordbuilder",3]],[[["arguments",3]],["recordbuilder",3]],[[["metadata",3]],["recordbuilder",3]],[[["level",4]],["recordbuilder",3]],[[["str",15]],["recordbuilder",3]],[[["option",4],["str",15]],["recordbuilder",3]],[[["str",15],["option",4]],["recordbuilder",3]],[[["option",4],["str",15]],["recordbuilder",3]],[[["str",15],["option",4]],["recordbuilder",3]],[[["u32",15],["option",4]],["recordbuilder",3]],[[],["record",3]],null,[[],["metadatabuilder",3]],[[],["level",4]],[[],["str",15]],null,[[],["metadatabuilder",3]],[[["level",4]],["metadatabuilder",3]],[[["str",15]],["metadatabuilder",3]],[[],["metadata",3]],null,[[["metadata",3]],["bool",15]],[[["record",3]]],[[]],[[["levelfilter",4]]],[[],["levelfilter",4]],[[["log",8]],[["setloggererror",3],["result",4]]],[[["log",8]],[["setloggererror",3],["result",4]]],null,null,[[],["log",8]],null,null,null,null,null,null,null,null,[[]],[[]],[[],["result",4]],[[]],[[]],[[],["result",4]],[[],["typeid",3]],[[]],[[]],[[],["result",4]],[[]],[[]],[[],["result",4]],[[],["typeid",3]],[[]],[[]],[[],["result",4]],[[]],[[]],[[],["result",4]],[[],["typeid",3]],[[]],[[]],[[],["result",4]],[[]],[[]],[[],["result",4]],[[],["typeid",3]],[[]],[[]],[[],["result",4]],[[]],[[]],[[],["result",4]],[[],["typeid",3]],[[]],[[]],[[],["result",4]],[[]],[[]],[[],["result",4]],[[],["typeid",3]],[[]],[[]],[[],["result",4]],[[]],[[]],[[],["result",4]],[[],["typeid",3]],[[]],[[]],[[],["result",4]],[[]],[[]],[[],["result",4]],[[],["typeid",3]],[[["formatter",3]],["result",6]],[[["formatter",3]],["result",6]],[[["formatter",3]],["result",6]],[[["formatter",3]],["result",6]],[[["formatter",3]],["result",6]],[[["formatter",3]],["result",6]],[[["formatter",3]],["result",6]],[[["formatter",3]],["result",6]],[[["formatter",3]],["result",6]],[[["formatter",3]],["result",6]],[[["formatter",3]],["result",6]],[[["formatter",3]],["result",6]],[[["level",4]],["bool",15]],[[["levelfilter",4]],["bool",15]],[[["levelfilter",4]],["bool",15]],[[["level",4]],["bool",15]],[[["metadata",3]],["bool",15]],[[["metadata",3]],["bool",15]],[[["metadatabuilder",3]],["bool",15]],[[["metadatabuilder",3]],["bool",15]],[[["parselevelerror",3]],["bool",15]],[[["parselevelerror",3]],["bool",15]],[[["level",4]],["ordering",4]],[[["levelfilter",4]],["ordering",4]],[[["metadata",3]],["ordering",4]],[[["metadatabuilder",3]],["ordering",4]],[[["level",4]],[["ordering",4],["option",4]]],[[["level",4]],["bool",15]],[[["level",4]],["bool",15]],[[["level",4]],["bool",15]],[[["level",4]],["bool",15]],[[["levelfilter",4]],[["ordering",4],["option",4]]],[[["levelfilter",4]],["bool",15]],[[["levelfilter",4]],["bool",15]],[[["levelfilter",4]],["bool",15]],[[["levelfilter",4]],["bool",15]],[[["levelfilter",4]],[["ordering",4],["option",4]]],[[["levelfilter",4]],["bool",15]],[[["levelfilter",4]],["bool",15]],[[["levelfilter",4]],["bool",15]],[[["levelfilter",4]],["bool",15]],[[["level",4]],[["ordering",4],["option",4]]],[[["level",4]],["bool",15]],[[["level",4]],["bool",15]],[[["level",4]],["bool",15]],[[["level",4]],["bool",15]],[[["metadata",3]],[["ordering",4],["option",4]]],[[["metadatabuilder",3]],[["ordering",4],["option",4]]],[[]],[[]],[[]],[[]],[[["str",15]],[["result",4],["level",4]]],[[["str",15]],[["levelfilter",4],["result",4]]],[[],["level",4]],[[],["levelfilter",4]],[[],["record",3]],[[],["metadata",3]]],"p":[[4,"Level"],[4,"LevelFilter"],[3,"Record"],[3,"RecordBuilder"],[3,"Metadata"],[3,"MetadataBuilder"],[8,"Log"],[3,"SetLoggerError"],[3,"ParseLevelError"]]},\ +"proc_macro2":{"doc":"A wrapper around the procedural macro API of the compiler…","t":[0,3,3,3,11,11,11,3,11,11,11,11,11,11,4,13,13,13,13,11,11,3,4,13,13,13,13,11,11,11,11,11,11,11,3,4,13,13,11,11,11,11,11,3,11,11,11,3,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11],"n":["token_stream","IntoIter","TokenStream","LexError","new","is_empty","span","Span","call_site","mixed_site","resolved_at","located_at","unwrap","join","TokenTree","Group","Ident","Punct","Literal","span","set_span","Group","Delimiter","Parenthesis","Brace","Bracket","None","new","delimiter","stream","span","span_open","span_close","set_span","Punct","Spacing","Alone","Joint","new","as_char","spacing","span","set_span","Ident","new","span","set_span","Literal","u8_suffixed","u16_suffixed","u32_suffixed","u64_suffixed","u128_suffixed","usize_suffixed","i8_suffixed","i16_suffixed","i32_suffixed","i64_suffixed","i128_suffixed","isize_suffixed","u8_unsuffixed","u16_unsuffixed","u32_unsuffixed","u64_unsuffixed","u128_unsuffixed","usize_unsuffixed","i8_unsuffixed","i16_unsuffixed","i32_unsuffixed","i64_unsuffixed","i128_unsuffixed","isize_unsuffixed","f64_unsuffixed","f64_suffixed","f32_unsuffixed","f32_suffixed","string","character","byte_string","span","set_span","subspan","from","into","into_iter","to_owned","clone_into","borrow","borrow_mut","try_from","try_into","type_id","from","into","to_owned","clone_into","to_string","borrow","borrow_mut","try_from","try_into","type_id","from","into","to_string","borrow","borrow_mut","try_from","try_into","type_id","from","into","to_owned","clone_into","borrow","borrow_mut","try_from","try_into","type_id","from","into","to_owned","clone_into","to_string","borrow","borrow_mut","try_from","try_into","type_id","from","into","to_owned","clone_into","to_string","borrow","borrow_mut","try_from","try_into","type_id","from","into","to_owned","clone_into","borrow","borrow_mut","try_from","try_into","type_id","from","into","to_owned","clone_into","to_string","borrow","borrow_mut","try_from","try_into","type_id","from","into","to_owned","clone_into","borrow","borrow_mut","try_from","try_into","type_id","from","into","to_owned","clone_into","to_string","borrow","borrow_mut","try_from","try_into","type_id","from","into","to_owned","clone_into","to_string","borrow","borrow_mut","try_from","try_into","type_id","from","from","from","from","from","from","from","extend","extend","into_iter","next","clone","clone","clone","clone","clone","clone","clone","clone","clone","clone","default","cmp","eq","eq","eq","eq","partial_cmp","fmt","fmt","fmt","fmt","fmt","fmt","fmt","fmt","fmt","fmt","fmt","fmt","fmt","fmt","fmt","fmt","fmt","fmt","hash","from_str","from_str","from_iter","from_iter"],"q":["proc_macro2","proc_macro2::token_stream","proc_macro2","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","proc_macro2::token_stream","","","","","","","","","","proc_macro2","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","proc_macro2::token_stream","proc_macro2","","","","","","","","","proc_macro2::token_stream","proc_macro2","","","","","","","","","","","","","","","","","proc_macro2::token_stream","proc_macro2","","","","","","","","","","",""],"d":["Public implementation details for the TokenStream type, …","An iterator over TokenStream’s TokenTrees.","An abstract stream of tokens, or more concretely a …","Error returned from TokenStream::from_str.","Returns an empty TokenStream containing no token trees.","Checks if this TokenStream is empty.","","A region of source code, along with macro expansion …","The span of the invocation of the current procedural …","The span located at the invocation of the procedural …","Creates a new span with the same line/column information …","Creates a new span with the same name resolution behavior …","Convert proc_macro2::Span to proc_macro::Span.","Create a new span encompassing self and other.","A single token or a delimited sequence of token trees …","A token stream surrounded by bracket delimiters.","An identifier.","A single punctuation character (+, ,, $, etc.).","A literal character (\'a\'), string (\\\"hello\\\"), number (2.3…","Returns the span of this tree, delegating to the span …","Configures the span for only this token.","A delimited token stream.","Describes how a sequence of token trees is delimited.","( ... )","{ ... }","[ ... ]","Ø ... Ø","Creates a new Group with the given delimiter and token …","Returns the delimiter of this Group","Returns the TokenStream of tokens that are delimited in …","Returns the span for the delimiters of this token stream, …","Returns the span pointing to the opening delimiter of …","Returns the span pointing to the closing delimiter of …","Configures the span for this Group’s delimiters, but …","A Punct is a single punctuation character like +, - or #.","Whether a Punct is followed immediately by another Punct …","E.g. + is Alone in + =, +ident or +().","E.g. + is Joint in += or \' is Joint in \'#.","Creates a new Punct from the given character and spacing.","Returns the value of this punctuation character as char.","Returns the spacing of this punctuation character, …","Returns the span for this punctuation character.","Configure the span for this punctuation character.","A word of Rust code, which may be a keyword or legal …","Creates a new Ident with the given string as well as the …","Returns the span of this Ident.","Configures the span of this Ident, possibly changing its …","A literal string (\\\"hello\\\"), byte string (b\\\"hello\\\"), …","Creates a new suffixed integer literal with the specified …","Creates a new suffixed integer literal with the specified …","Creates a new suffixed integer literal with the specified …","Creates a new suffixed integer literal with the specified …","Creates a new suffixed integer literal with the specified …","Creates a new suffixed integer literal with the specified …","Creates a new suffixed integer literal with the specified …","Creates a new suffixed integer literal with the specified …","Creates a new suffixed integer literal with the specified …","Creates a new suffixed integer literal with the specified …","Creates a new suffixed integer literal with the specified …","Creates a new suffixed integer literal with the specified …","Creates a new unsuffixed integer literal with the …","Creates a new unsuffixed integer literal with the …","Creates a new unsuffixed integer literal with the …","Creates a new unsuffixed integer literal with the …","Creates a new unsuffixed integer literal with the …","Creates a new unsuffixed integer literal with the …","Creates a new unsuffixed integer literal with the …","Creates a new unsuffixed integer literal with the …","Creates a new unsuffixed integer literal with the …","Creates a new unsuffixed integer literal with the …","Creates a new unsuffixed integer literal with the …","Creates a new unsuffixed integer literal with the …","Creates a new unsuffixed floating-point literal.","Creates a new suffixed floating-point literal.","Creates a new unsuffixed floating-point literal.","Creates a new suffixed floating-point literal.","String literal.","Character literal.","Byte string literal.","Returns the span encompassing this literal.","Configures the span associated for this literal.","Returns a Span that is a subset of self.span() containing …","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","",""],"i":[0,0,0,0,1,1,2,0,3,3,3,3,3,3,0,4,4,4,4,4,4,0,0,5,5,5,5,6,6,6,6,6,6,6,0,0,7,7,8,8,8,8,8,0,9,9,9,0,10,10,10,10,10,10,10,10,10,10,10,10,10,10,10,10,10,10,10,10,10,10,10,10,10,10,10,10,10,10,10,10,10,10,11,11,11,11,11,11,11,11,11,11,1,1,1,1,1,1,1,1,1,1,2,2,2,2,2,2,2,2,3,3,3,3,3,3,3,3,3,4,4,4,4,4,4,4,4,4,4,6,6,6,6,6,6,6,6,6,6,5,5,5,5,5,5,5,5,5,8,8,8,8,8,8,8,8,8,8,7,7,7,7,7,7,7,7,7,9,9,9,9,9,9,9,9,9,9,10,10,10,10,10,10,10,10,10,10,3,1,1,4,4,4,4,1,1,1,11,1,3,4,6,5,8,7,9,10,11,1,9,5,7,9,9,9,1,2,3,4,5,6,7,8,9,10,11,1,2,4,6,8,9,10,9,1,10,1,1],"f":[null,null,null,null,[[],["tokenstream",3]],[[],["bool",15]],[[],["span",3]],null,[[],["span",3]],[[],["span",3]],[[["span",3]],["span",3]],[[["span",3]],["span",3]],[[],["span",3]],[[["span",3]],[["option",4],["span",3]]],null,null,null,null,null,[[],["span",3]],[[["span",3]]],null,null,null,null,null,null,[[["delimiter",4],["tokenstream",3]],["group",3]],[[],["delimiter",4]],[[],["tokenstream",3]],[[],["span",3]],[[],["span",3]],[[],["span",3]],[[["span",3]]],null,null,null,null,[[["char",15],["spacing",4]],["punct",3]],[[],["char",15]],[[],["spacing",4]],[[],["span",3]],[[["span",3]]],null,[[["span",3],["str",15]],["ident",3]],[[],["span",3]],[[["span",3]]],null,[[["u8",15]],["literal",3]],[[["u16",15]],["literal",3]],[[["u32",15]],["literal",3]],[[["u64",15]],["literal",3]],[[["u128",15]],["literal",3]],[[["usize",15]],["literal",3]],[[["i8",15]],["literal",3]],[[["i16",15]],["literal",3]],[[["i32",15]],["literal",3]],[[["i64",15]],["literal",3]],[[["i128",15]],["literal",3]],[[["isize",15]],["literal",3]],[[["u8",15]],["literal",3]],[[["u16",15]],["literal",3]],[[["u32",15]],["literal",3]],[[["u64",15]],["literal",3]],[[["u128",15]],["literal",3]],[[["usize",15]],["literal",3]],[[["i8",15]],["literal",3]],[[["i16",15]],["literal",3]],[[["i32",15]],["literal",3]],[[["i64",15]],["literal",3]],[[["i128",15]],["literal",3]],[[["isize",15]],["literal",3]],[[["f64",15]],["literal",3]],[[["f64",15]],["literal",3]],[[["f32",15]],["literal",3]],[[["f32",15]],["literal",3]],[[["str",15]],["literal",3]],[[["char",15]],["literal",3]],[[],["literal",3]],[[],["span",3]],[[["span",3]]],[[["usize",15],["rangebounds",8]],[["option",4],["span",3]]],[[]],[[]],[[]],[[]],[[]],[[]],[[]],[[],["result",4]],[[],["result",4]],[[],["typeid",3]],[[]],[[]],[[]],[[]],[[],["string",3]],[[]],[[]],[[],["result",4]],[[],["result",4]],[[],["typeid",3]],[[]],[[]],[[],["string",3]],[[]],[[]],[[],["result",4]],[[],["result",4]],[[],["typeid",3]],[[]],[[]],[[]],[[]],[[]],[[]],[[],["result",4]],[[],["result",4]],[[],["typeid",3]],[[]],[[]],[[]],[[]],[[],["string",3]],[[]],[[]],[[],["result",4]],[[],["result",4]],[[],["typeid",3]],[[]],[[]],[[]],[[]],[[],["string",3]],[[]],[[]],[[],["result",4]],[[],["result",4]],[[],["typeid",3]],[[]],[[]],[[]],[[]],[[]],[[]],[[],["result",4]],[[],["result",4]],[[],["typeid",3]],[[]],[[]],[[]],[[]],[[],["string",3]],[[]],[[]],[[],["result",4]],[[],["result",4]],[[],["typeid",3]],[[]],[[]],[[]],[[]],[[]],[[]],[[],["result",4]],[[],["result",4]],[[],["typeid",3]],[[]],[[]],[[]],[[]],[[],["string",3]],[[]],[[]],[[],["result",4]],[[],["result",4]],[[],["typeid",3]],[[]],[[]],[[]],[[]],[[],["string",3]],[[]],[[]],[[],["result",4]],[[],["result",4]],[[],["typeid",3]],[[["span",3]],["span",3]],[[["tokenstream",3]],["tokenstream",3]],[[["tokentree",4]]],[[["group",3]],["tokentree",4]],[[["ident",3]],["tokentree",4]],[[["punct",3]],["tokentree",4]],[[["literal",3]],["tokentree",4]],[[["intoiterator",8]]],[[["intoiterator",8]]],[[],["intoiter",3]],[[],[["option",4],["tokentree",4]]],[[],["tokenstream",3]],[[],["span",3]],[[],["tokentree",4]],[[],["group",3]],[[],["delimiter",4]],[[],["punct",3]],[[],["spacing",4]],[[],["ident",3]],[[],["literal",3]],[[],["intoiter",3]],[[]],[[["ident",3]],["ordering",4]],[[["delimiter",4]],["bool",15]],[[["spacing",4]],["bool",15]],[[["ident",3]],["bool",15]],[[],["bool",15]],[[["ident",3]],[["option",4],["ordering",4]]],[[["formatter",3]],["result",6]],[[["formatter",3]],["result",6]],[[["formatter",3]],["result",6]],[[["formatter",3]],["result",6]],[[["formatter",3]],["result",6]],[[["formatter",3]],["result",6]],[[["formatter",3]],["result",6]],[[["formatter",3]],["result",6]],[[["formatter",3]],["result",6]],[[["formatter",3]],["result",6]],[[["formatter",3]],["result",6]],[[["formatter",3]],["result",6]],[[["formatter",3]],["result",6]],[[["formatter",3]],["result",6]],[[["formatter",3]],["result",6]],[[["formatter",3]],["result",6]],[[["formatter",3]],["result",6]],[[["formatter",3]],["result",6]],[[]],[[["str",15]],[["result",4],["tokenstream",3],["lexerror",3]]],[[["str",15]],[["result",4],["lexerror",3]]],[[["intoiterator",8]]],[[["intoiterator",8]]]],"p":[[3,"TokenStream"],[3,"LexError"],[3,"Span"],[4,"TokenTree"],[4,"Delimiter"],[3,"Group"],[4,"Spacing"],[3,"Punct"],[3,"Ident"],[3,"Literal"],[3,"IntoIter"]]},\ +"quote":{"doc":"github crates-io docs-rs","t":[8,10,10,10,10,8,10,11,8,10,11,11,14,14,14,11,11,11],"n":["TokenStreamExt","append","append_all","append_separated","append_terminated","IdentFragment","fmt","span","ToTokens","to_tokens","to_token_stream","into_token_stream","format_ident","quote","quote_spanned","span","to_token_stream","into_token_stream"],"q":["quote","","","","","","","","","","","","","","","","",""],"d":["TokenStream extension trait with methods for appending …","For use by ToTokens implementations.","For use by ToTokens implementations.","For use by ToTokens implementations.","For use by ToTokens implementations.","Specialized formatting trait used by format_ident!.","Format this value as an identifier fragment.","Span associated with this IdentFragment.","Types that can be interpolated inside a quote! invocation.","Write self to the given TokenStream.","Convert self directly into a TokenStream object.","Convert self directly into a TokenStream object.","Formatting macro for constructing Idents.","The whole point.","Same as quote!, but applies a given span to all tokens …","Span associated with this IdentFragment.","Convert self directly into a TokenStream object.","Convert self directly into a TokenStream object."],"i":[0,1,1,1,1,0,2,2,0,3,3,3,0,0,0,2,3,3],"f":[null,[[]],[[]],[[]],[[]],null,[[["formatter",3]],["result",6]],[[],[["option",4],["span",3]]],null,[[["tokenstream",3]]],[[],["tokenstream",3]],[[],["tokenstream",3]],null,null,null,[[],[["option",4],["span",3]]],[[],["tokenstream",3]],[[],["tokenstream",3]]],"p":[[8,"TokenStreamExt"],[8,"IdentFragment"],[8,"ToTokens"]]},\ +"syn":{"doc":"github crates-io docs-rs","t":[0,8,3,12,3,12,3,12,3,12,3,12,3,12,3,12,3,12,3,12,3,12,3,12,3,12,3,12,3,12,3,12,3,12,3,12,3,12,3,12,3,12,3,12,3,12,3,12,3,12,3,12,3,12,3,12,3,12,3,12,3,12,3,12,3,12,3,12,3,12,3,12,3,12,3,12,3,12,3,12,3,12,3,12,3,12,3,12,3,12,3,12,3,12,3,12,3,12,3,12,3,12,3,12,3,12,3,12,3,12,3,12,3,12,3,12,3,12,3,12,3,12,3,12,3,12,3,12,3,12,3,12,3,12,3,12,3,12,3,12,3,12,3,12,3,12,3,12,3,12,3,12,3,12,3,12,3,12,3,12,3,12,3,12,3,12,3,12,3,12,3,12,3,12,3,12,3,12,3,12,3,12,3,12,3,12,3,12,3,12,3,12,3,12,3,12,3,12,3,12,3,12,11,3,12,11,3,12,11,3,12,11,0,3,11,11,11,3,11,11,11,11,11,11,11,11,11,11,0,8,10,18,10,0,3,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,3,3,3,3,3,3,4,13,13,11,11,11,11,11,11,0,8,10,0,8,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,0,0,8,10,3,6,3,8,8,10,6,3,3,11,11,11,11,11,11,11,11,11,11,11,11,11,11,8,16,10,11,11,3,11,11,11,11,11,11,3,4,13,13,3,12,12,12,12,12,6,4,13,13,13,3,12,12,12,3,12,12,12,4,13,13,3,12,12,12,12,12,4,13,13,13,3,12,12,3,12,12,3,12,12,12,12,3,12,3,12,3,12,12,12,12,4,13,13,13,13,4,13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,3,3,3,3,3,3,12,12,12,12,3,3,3,3,12,12,12,12,3,12,12,12,12,3,3,3,12,12,12,12,3,3,3,3,12,12,12,12,3,3,12,12,3,3,3,3,3,12,12,12,3,12,12,12,3,3,3,3,3,3,3,3,3,3,12,12,12,3,3,3,3,12,12,4,13,13,3,12,12,12,12,3,12,12,12,12,12,12,12,4,13,13,13,3,12,12,12,12,3,12,12,12,12,3,12,12,12,3,12,12,12,3,12,12,12,12,3,12,12,12,12,4,13,13,3,12,12,12,12,12,12,4,13,13,3,12,12,4,13,13,13,3,3,3,3,12,12,4,13,13,13,13,13,13,13,13,3,12,12,3,3,3,3,3,3,4,13,13,3,12,12,12,12,4,13,13,13,4,13,13,13,3,12,12,12,3,12,12,12,3,12,12,3,12,12,12,12,12,4,13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,4,13,13,13,3,12,12,3,12,12,12,4,13,13,4,13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,3,12,12,12,12,3,12,12,12,12,12,12,12,12,3,12,12,3,12,12,3,12,3,12,3,12,3,12,12,3,12,12,3,12,12,12,12,3,12,12,12,12,3,12,12,3,12,12,3,12,12,3,12,12,3,12,12,12,12,3,12,12,12,3,12,12,12,4,13,13,13,13,13,3,12,12,12,3,12,12,4,13,13,13,3,12,12,3,12,12,12,12,12,3,6,5,5,5,14,14,14,14,14,14,14,14,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11],"n":["token","Token","Underscore","spans","Abstract","span","As","span","Async","span","Auto","span","Await","span","Become","span","Box","span","Break","span","Const","span","Continue","span","Crate","span","Default","span","Do","span","Dyn","span","Else","span","Enum","span","Extern","span","Final","span","Fn","span","For","span","If","span","Impl","span","In","span","Let","span","Loop","span","Macro","span","Match","span","Mod","span","Move","span","Mut","span","Override","span","Priv","span","Pub","span","Ref","span","Return","span","SelfType","span","SelfValue","span","Static","span","Struct","span","Super","span","Trait","span","Try","span","Type","span","Typeof","span","Union","span","Unsafe","span","Unsized","span","Use","span","Virtual","span","Where","span","While","span","Yield","span","Add","spans","AddEq","spans","And","spans","AndAnd","spans","AndEq","spans","At","spans","Bang","spans","Caret","spans","CaretEq","spans","Colon","spans","Colon2","spans","Comma","spans","Div","spans","DivEq","spans","Dollar","spans","Dot","spans","Dot2","spans","Dot3","spans","DotDotEq","spans","Eq","spans","EqEq","spans","Ge","spans","Gt","spans","Le","spans","Lt","spans","MulEq","spans","Ne","spans","Or","spans","OrEq","spans","OrOr","spans","Pound","spans","Question","spans","RArrow","spans","LArrow","spans","Rem","spans","RemEq","spans","FatArrow","spans","Semi","spans","Shl","spans","ShlEq","spans","Shr","spans","ShrEq","spans","Star","spans","Sub","spans","SubEq","spans","Tilde","spans","Brace","span","surround","Bracket","span","surround","Paren","span","surround","Group","span","surround","buffer","TokenBuffer","new","new2","begin","Cursor","empty","eof","group","ident","punct","literal","lifetime","token_stream","token_tree","span","ext","IdentExt","parse_any","peek_any","unraw","punctuated","Punctuated","new","is_empty","len","first","first_mut","last","last_mut","iter","iter_mut","pairs","pairs_mut","into_pairs","push_value","push_punct","pop","trailing_punct","empty_or_trailing","push","insert","clear","parse_terminated","parse_terminated_with","parse_separated_nonempty","parse_separated_nonempty_with","Pairs","PairsMut","IntoPairs","IntoIter","Iter","IterMut","Pair","Punctuated","End","into_value","value","value_mut","punct","new","into_tuple","spanned","Spanned","span","visit","Visit","visit_abi","visit_angle_bracketed_generic_arguments","visit_attr_style","visit_attribute","visit_bare_fn_arg","visit_bin_op","visit_binding","visit_bound_lifetimes","visit_const_param","visit_constraint","visit_data","visit_data_enum","visit_data_struct","visit_data_union","visit_derive_input","visit_expr","visit_expr_binary","visit_expr_call","visit_expr_cast","visit_expr_field","visit_expr_index","visit_expr_lit","visit_expr_paren","visit_expr_path","visit_expr_unary","visit_field","visit_fields","visit_fields_named","visit_fields_unnamed","visit_generic_argument","visit_generic_param","visit_generics","visit_ident","visit_index","visit_lifetime","visit_lifetime_def","visit_lit","visit_lit_bool","visit_lit_byte","visit_lit_byte_str","visit_lit_char","visit_lit_float","visit_lit_int","visit_lit_str","visit_macro","visit_macro_delimiter","visit_member","visit_meta","visit_meta_list","visit_meta_name_value","visit_nested_meta","visit_parenthesized_generic_arguments","visit_path","visit_path_arguments","visit_path_segment","visit_predicate_eq","visit_predicate_lifetime","visit_predicate_type","visit_qself","visit_return_type","visit_span","visit_trait_bound","visit_trait_bound_modifier","visit_type","visit_type_array","visit_type_bare_fn","visit_type_group","visit_type_impl_trait","visit_type_infer","visit_type_macro","visit_type_never","visit_type_param","visit_type_param_bound","visit_type_paren","visit_type_path","visit_type_ptr","visit_type_reference","visit_type_slice","visit_type_trait_object","visit_type_tuple","visit_un_op","visit_variadic","visit_variant","visit_vis_crate","visit_vis_public","visit_vis_restricted","visit_visibility","visit_where_clause","visit_where_predicate","visit_abi","visit_angle_bracketed_generic_arguments","visit_attr_style","visit_attribute","visit_bare_fn_arg","visit_bin_op","visit_binding","visit_bound_lifetimes","visit_const_param","visit_constraint","visit_data","visit_data_enum","visit_data_struct","visit_data_union","visit_derive_input","visit_expr","visit_expr_binary","visit_expr_call","visit_expr_cast","visit_expr_field","visit_expr_index","visit_expr_lit","visit_expr_paren","visit_expr_path","visit_expr_unary","visit_field","visit_fields","visit_fields_named","visit_fields_unnamed","visit_generic_argument","visit_generic_param","visit_generics","visit_ident","visit_index","visit_lifetime","visit_lifetime_def","visit_lit","visit_lit_bool","visit_lit_byte","visit_lit_byte_str","visit_lit_char","visit_lit_float","visit_lit_int","visit_lit_str","visit_macro","visit_macro_delimiter","visit_member","visit_meta","visit_meta_list","visit_meta_name_value","visit_nested_meta","visit_parenthesized_generic_arguments","visit_path","visit_path_arguments","visit_path_segment","visit_predicate_eq","visit_predicate_lifetime","visit_predicate_type","visit_qself","visit_return_type","visit_span","visit_trait_bound","visit_trait_bound_modifier","visit_type","visit_type_array","visit_type_bare_fn","visit_type_group","visit_type_impl_trait","visit_type_infer","visit_type_macro","visit_type_never","visit_type_param","visit_type_param_bound","visit_type_paren","visit_type_path","visit_type_ptr","visit_type_reference","visit_type_slice","visit_type_trait_object","visit_type_tuple","visit_un_op","visit_variadic","visit_variant","visit_vis_crate","visit_vis_public","visit_vis_restricted","visit_visibility","visit_where_clause","visit_where_predicate","parse","discouraged","Speculative","advance_to","Error","Result","Lookahead1","Peek","Parse","parse","ParseStream","ParseBuffer","StepCursor","error","parse","call","peek","peek2","peek3","parse_terminated","is_empty","lookahead1","fork","error","step","span","cursor","Parser","Output","parse2","parse","parse_str","Nothing","new","new_spanned","span","to_compile_error","into_compile_error","combine","Ident","AttrStyle","Outer","Inner","Attribute","pound_token","style","bracket_token","path","tokens","AttributeArgs","Meta","Path","List","NameValue","MetaList","path","paren_token","nested","MetaNameValue","path","eq_token","lit","NestedMeta","Meta","Lit","Field","attrs","vis","ident","colon_token","ty","Fields","Named","Unnamed","Unit","FieldsNamed","brace_token","named","FieldsUnnamed","paren_token","unnamed","Variant","attrs","ident","fields","discriminant","VisCrate","crate_token","VisPublic","pub_token","VisRestricted","pub_token","paren_token","in_token","path","Visibility","Public","Crate","Restricted","Inherited","Expr","Array","Assign","AssignOp","Async","Await","Binary","Block","Box","Break","Call","Cast","Closure","Continue","Field","ForLoop","Group","If","Index","Let","Lit","Loop","Macro","Match","MethodCall","Paren","Path","Range","Reference","Repeat","Return","Struct","Try","TryBlock","Tuple","Type","Unary","Unsafe","Verbatim","While","Yield","ExprArray","ExprAssign","ExprAssignOp","ExprAsync","ExprAwait","ExprBinary","attrs","left","op","right","ExprBlock","ExprBox","ExprBreak","ExprCall","attrs","func","paren_token","args","ExprCast","attrs","expr","as_token","ty","ExprClosure","ExprContinue","ExprField","attrs","base","dot_token","member","ExprForLoop","ExprGroup","ExprIf","ExprIndex","attrs","expr","bracket_token","index","ExprLet","ExprLit","attrs","lit","ExprLoop","ExprMacro","ExprMatch","ExprMethodCall","ExprParen","attrs","paren_token","expr","ExprPath","attrs","qself","path","ExprRange","ExprReference","ExprRepeat","ExprReturn","ExprStruct","ExprTry","ExprTryBlock","ExprTuple","ExprType","ExprUnary","attrs","op","expr","ExprUnsafe","ExprWhile","ExprYield","Index","index","span","Member","Named","Unnamed","BoundLifetimes","for_token","lt_token","lifetimes","gt_token","ConstParam","attrs","const_token","ident","colon_token","ty","eq_token","default","GenericParam","Type","Lifetime","Const","Generics","lt_token","params","gt_token","where_clause","LifetimeDef","attrs","lifetime","colon_token","bounds","PredicateEq","lhs_ty","eq_token","rhs_ty","PredicateLifetime","lifetime","colon_token","bounds","PredicateType","lifetimes","bounded_ty","colon_token","bounds","TraitBound","paren_token","modifier","lifetimes","path","TraitBoundModifier","None","Maybe","TypeParam","attrs","ident","colon_token","bounds","eq_token","default","TypeParamBound","Trait","Lifetime","WhereClause","where_token","predicates","WherePredicate","Type","Lifetime","Eq","ImplGenerics","Turbofish","TypeGenerics","Lifetime","apostrophe","ident","Lit","Str","ByteStr","Byte","Char","Int","Float","Bool","Verbatim","LitBool","value","span","LitByte","LitByteStr","LitChar","LitFloat","LitInt","LitStr","StrStyle","Cooked","Raw","Macro","path","bang_token","delimiter","tokens","MacroDelimiter","Paren","Brace","Bracket","Data","Struct","Enum","Union","DataEnum","enum_token","brace_token","variants","DataStruct","struct_token","fields","semi_token","DataUnion","union_token","fields","DeriveInput","attrs","vis","ident","generics","data","BinOp","Add","Sub","Mul","Div","Rem","And","Or","BitXor","BitAnd","BitOr","Shl","Shr","Eq","Lt","Le","Ne","Ge","Gt","AddEq","SubEq","MulEq","DivEq","RemEq","BitXorEq","BitAndEq","BitOrEq","ShlEq","ShrEq","UnOp","Deref","Not","Neg","Abi","extern_token","name","BareFnArg","attrs","name","ty","ReturnType","Default","Type","Type","Array","BareFn","Group","ImplTrait","Infer","Macro","Never","Paren","Path","Ptr","Reference","Slice","TraitObject","Tuple","Verbatim","TypeArray","bracket_token","elem","semi_token","len","TypeBareFn","lifetimes","unsafety","abi","fn_token","paren_token","inputs","variadic","output","TypeGroup","group_token","elem","TypeImplTrait","impl_token","bounds","TypeInfer","underscore_token","TypeMacro","mac","TypeNever","bang_token","TypeParen","paren_token","elem","TypePath","qself","path","TypePtr","star_token","const_token","mutability","elem","TypeReference","and_token","lifetime","mutability","elem","TypeSlice","bracket_token","elem","TypeTraitObject","dyn_token","bounds","TypeTuple","paren_token","elems","Variadic","attrs","dots","AngleBracketedGenericArguments","colon2_token","lt_token","args","gt_token","Binding","ident","eq_token","ty","Constraint","ident","colon_token","bounds","GenericArgument","Lifetime","Type","Binding","Constraint","Const","ParenthesizedGenericArguments","paren_token","inputs","output","Path","leading_colon","segments","PathArguments","None","AngleBracketed","Parenthesized","PathSegment","ident","arguments","QSelf","lt_token","ty","position","as_token","gt_token","Error","Result","parse","parse2","parse_str","parenthesized","braced","bracketed","Token","parse_quote","parse_macro_input","custom_keyword","custom_punctuation","span","from","into","to_owned","clone_into","borrow","borrow_mut","try_from","try_into","type_id","span","from","into","to_owned","clone_into","borrow","borrow_mut","try_from","try_into","type_id","span","from","into","to_owned","clone_into","borrow","borrow_mut","try_from","try_into","type_id","span","from","into","to_owned","clone_into","borrow","borrow_mut","try_from","try_into","type_id","span","from","into","to_owned","clone_into","borrow","borrow_mut","try_from","try_into","type_id","span","from","into","to_owned","clone_into","borrow","borrow_mut","try_from","try_into","type_id","span","from","into","to_owned","clone_into","borrow","borrow_mut","try_from","try_into","type_id","span","from","into","to_owned","clone_into","borrow","borrow_mut","try_from","try_into","type_id","span","from","into","to_owned","clone_into","borrow","borrow_mut","try_from","try_into","type_id","span","from","into","to_owned","clone_into","borrow","borrow_mut","try_from","try_into","type_id","span","from","into","to_owned","clone_into","borrow","borrow_mut","try_from","try_into","type_id","span","from","into","to_owned","clone_into","borrow","borrow_mut","try_from","try_into","type_id","span","from","into","to_owned","clone_into","borrow","borrow_mut","try_from","try_into","type_id","span","from","into","to_owned","clone_into","borrow","borrow_mut","try_from","try_into","type_id","span","from","into","to_owned","clone_into","borrow","borrow_mut","try_from","try_into","type_id","span","from","into","to_owned","clone_into","borrow","borrow_mut","try_from","try_into","type_id","span","from","into","to_owned","clone_into","borrow","borrow_mut","try_from","try_into","type_id","span","from","into","to_owned","clone_into","borrow","borrow_mut","try_from","try_into","type_id","span","from","into","to_owned","clone_into","borrow","borrow_mut","try_from","try_into","type_id","span","from","into","to_owned","clone_into","borrow","borrow_mut","try_from","try_into","type_id","span","from","into","to_owned","clone_into","borrow","borrow_mut","try_from","try_into","type_id","span","from","into","to_owned","clone_into","borrow","borrow_mut","try_from","try_into","type_id","span","from","into","to_owned","clone_into","borrow","borrow_mut","try_from","try_into","type_id","span","from","into","to_owned","clone_into","borrow","borrow_mut","try_from","try_into","type_id","span","from","into","to_owned","clone_into","borrow","borrow_mut","try_from","try_into","type_id","span","from","into","to_owned","clone_into","borrow","borrow_mut","try_from","try_into","type_id","span","from","into","to_owned","clone_into","borrow","borrow_mut","try_from","try_into","type_id","span","from","into","to_owned","clone_into","borrow","borrow_mut","try_from","try_into","type_id","span","from","into","to_owned","clone_into","borrow","borrow_mut","try_from","try_into","type_id","span","from","into","to_owned","clone_into","borrow","borrow_mut","try_from","try_into","type_id","span","from","into","to_owned","clone_into","borrow","borrow_mut","try_from","try_into","type_id","span","from","into","to_owned","clone_into","borrow","borrow_mut","try_from","try_into","type_id","span","from","into","to_owned","clone_into","borrow","borrow_mut","try_from","try_into","type_id","span","from","into","to_owned","clone_into","borrow","borrow_mut","try_from","try_into","type_id","span","from","into","to_owned","clone_into","borrow","borrow_mut","try_from","try_into","type_id","span","from","into","to_owned","clone_into","borrow","borrow_mut","try_from","try_into","type_id","span","from","into","to_owned","clone_into","borrow","borrow_mut","try_from","try_into","type_id","span","from","into","to_owned","clone_into","borrow","borrow_mut","try_from","try_into","type_id","span","from","into","to_owned","clone_into","borrow","borrow_mut","try_from","try_into","type_id","span","from","into","to_owned","clone_into","borrow","borrow_mut","try_from","try_into","type_id","span","from","into","to_owned","clone_into","borrow","borrow_mut","try_from","try_into","type_id","span","from","into","to_owned","clone_into","borrow","borrow_mut","try_from","try_into","type_id","span","from","into","to_owned","clone_into","borrow","borrow_mut","try_from","try_into","type_id","span","from","into","to_owned","clone_into","borrow","borrow_mut","try_from","try_into","type_id","span","from","into","to_owned","clone_into","borrow","borrow_mut","try_from","try_into","type_id","span","from","into","to_owned","clone_into","borrow","borrow_mut","try_from","try_into","type_id","span","from","into","to_owned","clone_into","borrow","borrow_mut","try_from","try_into","type_id","span","from","into","to_owned","clone_into","borrow","borrow_mut","try_from","try_into","type_id","span","from","into","to_owned","clone_into","borrow","borrow_mut","try_from","try_into","type_id","span","from","into","to_owned","clone_into","borrow","borrow_mut","try_from","try_into","type_id","span","from","into","to_owned","clone_into","borrow","borrow_mut","try_from","try_into","type_id","span","from","into","to_owned","clone_into","borrow","borrow_mut","try_from","try_into","type_id","span","from","into","to_owned","clone_into","borrow","borrow_mut","try_from","try_into","type_id","span","from","into","to_owned","clone_into","borrow","borrow_mut","try_from","try_into","type_id","span","from","into","to_owned","clone_into","borrow","borrow_mut","try_from","try_into","type_id","span","from","into","to_owned","clone_into","borrow","borrow_mut","try_from","try_into","type_id","span","from","into","to_owned","clone_into","borrow","borrow_mut","try_from","try_into","type_id","span","from","into","to_owned","clone_into","borrow","borrow_mut","try_from","try_into","type_id","span","from","into","to_owned","clone_into","borrow","borrow_mut","try_from","try_into","type_id","span","from","into","to_owned","clone_into","borrow","borrow_mut","try_from","try_into","type_id","span","from","into","to_owned","clone_into","borrow","borrow_mut","try_from","try_into","type_id","span","from","into","to_owned","clone_into","borrow","borrow_mut","try_from","try_into","type_id","span","from","into","to_owned","clone_into","borrow","borrow_mut","try_from","try_into","type_id","span","from","into","to_owned","clone_into","borrow","borrow_mut","try_from","try_into","type_id","span","from","into","to_owned","clone_into","borrow","borrow_mut","try_from","try_into","type_id","span","from","into","to_owned","clone_into","borrow","borrow_mut","try_from","try_into","type_id","span","from","into","to_owned","clone_into","borrow","borrow_mut","try_from","try_into","type_id","span","from","into","to_owned","clone_into","borrow","borrow_mut","try_from","try_into","type_id","span","from","into","to_owned","clone_into","borrow","borrow_mut","try_from","try_into","type_id","span","from","into","to_owned","clone_into","borrow","borrow_mut","try_from","try_into","type_id","span","from","into","to_owned","clone_into","borrow","borrow_mut","try_from","try_into","type_id","span","from","into","to_owned","clone_into","borrow","borrow_mut","try_from","try_into","type_id","span","from","into","to_owned","clone_into","borrow","borrow_mut","try_from","try_into","type_id","span","from","into","to_owned","clone_into","borrow","borrow_mut","try_from","try_into","type_id","span","from","into","to_owned","clone_into","borrow","borrow_mut","try_from","try_into","type_id","span","from","into","to_owned","clone_into","borrow","borrow_mut","try_from","try_into","type_id","span","from","into","to_owned","clone_into","borrow","borrow_mut","try_from","try_into","type_id","span","from","into","to_owned","clone_into","borrow","borrow_mut","try_from","try_into","type_id","span","from","into","to_owned","clone_into","borrow","borrow_mut","try_from","try_into","type_id","span","from","into","to_owned","clone_into","borrow","borrow_mut","try_from","try_into","type_id","span","from","into","to_owned","clone_into","borrow","borrow_mut","try_from","try_into","type_id","span","from","into","to_owned","clone_into","borrow","borrow_mut","try_from","try_into","type_id","span","from","into","to_owned","clone_into","borrow","borrow_mut","try_from","try_into","type_id","span","from","into","to_owned","clone_into","borrow","borrow_mut","try_from","try_into","type_id","span","from","into","to_owned","clone_into","borrow","borrow_mut","try_from","try_into","type_id","span","from","into","to_owned","clone_into","borrow","borrow_mut","try_from","try_into","type_id","span","from","into","to_owned","clone_into","borrow","borrow_mut","try_from","try_into","type_id","span","from","into","to_owned","clone_into","borrow","borrow_mut","try_from","try_into","type_id","span","from","into","to_owned","clone_into","borrow","borrow_mut","try_from","try_into","type_id","span","from","into","to_owned","clone_into","borrow","borrow_mut","try_from","try_into","type_id","span","from","into","to_owned","clone_into","borrow","borrow_mut","try_from","try_into","type_id","span","from","into","to_owned","clone_into","borrow","borrow_mut","try_from","try_into","type_id","span","from","into","to_owned","clone_into","borrow","borrow_mut","try_from","try_into","type_id","span","from","into","to_owned","clone_into","borrow","borrow_mut","try_from","try_into","type_id","span","from","into","to_owned","clone_into","borrow","borrow_mut","try_from","try_into","type_id","span","from","into","to_owned","clone_into","borrow","borrow_mut","try_from","try_into","type_id","span","from","into","to_owned","clone_into","borrow","borrow_mut","try_from","try_into","type_id","span","from","into","to_owned","clone_into","borrow","borrow_mut","try_from","try_into","type_id","span","from","into","to_owned","clone_into","borrow","borrow_mut","try_from","try_into","type_id","from","into","to_owned","clone_into","borrow","borrow_mut","try_from","try_into","type_id","from","into","to_owned","clone_into","borrow","borrow_mut","try_from","try_into","type_id","from","into","to_owned","clone_into","borrow","borrow_mut","try_from","try_into","type_id","from","into","to_owned","clone_into","borrow","borrow_mut","try_from","try_into","type_id","span","from","into","to_owned","clone_into","to_string","borrow","borrow_mut","try_from","try_into","type_id","span","from","into","to_owned","clone_into","borrow","borrow_mut","try_from","try_into","type_id","from","into","to_owned","clone_into","borrow","borrow_mut","try_from","try_into","type_id","span","from","into","to_owned","clone_into","borrow","borrow_mut","try_from","try_into","type_id","span","from","into","to_owned","clone_into","borrow","borrow_mut","try_from","try_into","type_id","span","from","into","to_owned","clone_into","borrow","borrow_mut","try_from","try_into","type_id","span","from","into","to_owned","clone_into","borrow","borrow_mut","try_from","try_into","type_id","span","from","into","to_owned","clone_into","borrow","borrow_mut","try_from","try_into","type_id","span","from","into","to_owned","clone_into","borrow","borrow_mut","try_from","try_into","type_id","span","from","into","to_owned","clone_into","borrow","borrow_mut","try_from","try_into","type_id","span","from","into","to_owned","clone_into","borrow","borrow_mut","try_from","try_into","type_id","span","from","into","to_owned","clone_into","borrow","borrow_mut","try_from","try_into","type_id","span","from","into","to_owned","clone_into","borrow","borrow_mut","try_from","try_into","type_id","span","from","into","to_owned","clone_into","borrow","borrow_mut","try_from","try_into","type_id","span","from","into","to_owned","clone_into","borrow","borrow_mut","try_from","try_into","type_id","span","from","into","to_owned","clone_into","borrow","borrow_mut","try_from","try_into","type_id","span","from","into","to_owned","clone_into","borrow","borrow_mut","try_from","try_into","type_id","span","from","into","borrow","borrow_mut","try_from","try_into","type_id","span","from","into","borrow","borrow_mut","try_from","try_into","type_id","span","from","into","borrow","borrow_mut","try_from","try_into","type_id","span","from","into","borrow","borrow_mut","try_from","try_into","type_id","span","from","into","borrow","borrow_mut","try_from","try_into","type_id","span","from","into","to_owned","clone_into","borrow","borrow_mut","try_from","try_into","type_id","span","from","into","borrow","borrow_mut","try_from","try_into","type_id","span","from","into","borrow","borrow_mut","try_from","try_into","type_id","span","from","into","borrow","borrow_mut","try_from","try_into","type_id","span","from","into","to_owned","clone_into","borrow","borrow_mut","try_from","try_into","type_id","span","from","into","to_owned","clone_into","borrow","borrow_mut","try_from","try_into","type_id","span","from","into","borrow","borrow_mut","try_from","try_into","type_id","span","from","into","borrow","borrow_mut","try_from","try_into","type_id","span","from","into","to_owned","clone_into","borrow","borrow_mut","try_from","try_into","type_id","span","from","into","borrow","borrow_mut","try_from","try_into","type_id","span","from","into","borrow","borrow_mut","try_from","try_into","type_id","span","from","into","borrow","borrow_mut","try_from","try_into","type_id","span","from","into","to_owned","clone_into","borrow","borrow_mut","try_from","try_into","type_id","span","from","into","borrow","borrow_mut","try_from","try_into","type_id","span","from","into","to_owned","clone_into","borrow","borrow_mut","try_from","try_into","type_id","span","from","into","borrow","borrow_mut","try_from","try_into","type_id","span","from","into","borrow","borrow_mut","try_from","try_into","type_id","span","from","into","borrow","borrow_mut","try_from","try_into","type_id","span","from","into","borrow","borrow_mut","try_from","try_into","type_id","span","from","into","to_owned","clone_into","borrow","borrow_mut","try_from","try_into","type_id","span","from","into","to_owned","clone_into","borrow","borrow_mut","try_from","try_into","type_id","span","from","into","borrow","borrow_mut","try_from","try_into","type_id","span","from","into","borrow","borrow_mut","try_from","try_into","type_id","span","from","into","borrow","borrow_mut","try_from","try_into","type_id","span","from","into","borrow","borrow_mut","try_from","try_into","type_id","span","from","into","borrow","borrow_mut","try_from","try_into","type_id","span","from","into","borrow","borrow_mut","try_from","try_into","type_id","span","from","into","borrow","borrow_mut","try_from","try_into","type_id","span","from","into","borrow","borrow_mut","try_from","try_into","type_id","span","from","into","borrow","borrow_mut","try_from","try_into","type_id","span","from","into","to_owned","clone_into","borrow","borrow_mut","try_from","try_into","type_id","span","from","into","borrow","borrow_mut","try_from","try_into","type_id","span","from","into","borrow","borrow_mut","try_from","try_into","type_id","span","from","into","borrow","borrow_mut","try_from","try_into","type_id","span","from","into","to_owned","clone_into","borrow","borrow_mut","try_from","try_into","type_id","span","from","into","to_owned","clone_into","borrow","borrow_mut","try_from","try_into","type_id","span","from","into","to_owned","clone_into","borrow","borrow_mut","try_from","try_into","type_id","span","from","into","to_owned","clone_into","borrow","borrow_mut","try_from","try_into","type_id","span","from","into","to_owned","clone_into","borrow","borrow_mut","try_from","try_into","type_id","span","from","into","to_owned","clone_into","borrow","borrow_mut","try_from","try_into","type_id","span","from","into","to_owned","clone_into","borrow","borrow_mut","try_from","try_into","type_id","span","from","into","to_owned","clone_into","borrow","borrow_mut","try_from","try_into","type_id","span","from","into","to_owned","clone_into","borrow","borrow_mut","try_from","try_into","type_id","span","from","into","to_owned","clone_into","borrow","borrow_mut","try_from","try_into","type_id","span","from","into","to_owned","clone_into","borrow","borrow_mut","try_from","try_into","type_id","span","from","into","to_owned","clone_into","borrow","borrow_mut","try_from","try_into","type_id","span","from","into","to_owned","clone_into","borrow","borrow_mut","try_from","try_into","type_id","span","from","into","to_owned","clone_into","borrow","borrow_mut","try_from","try_into","type_id","span","from","into","to_owned","clone_into","borrow","borrow_mut","try_from","try_into","type_id","span","from","into","to_owned","clone_into","borrow","borrow_mut","try_from","try_into","type_id","span","from","into","to_owned","clone_into","borrow","borrow_mut","try_from","try_into","type_id","span","from","into","to_owned","clone_into","borrow","borrow_mut","try_from","try_into","type_id","span","from","into","to_owned","clone_into","borrow","borrow_mut","try_from","try_into","type_id","span","from","into","to_owned","clone_into","to_string","borrow","borrow_mut","try_from","try_into","type_id","span","from","into","to_owned","clone_into","borrow","borrow_mut","try_from","try_into","type_id","span","from","into","to_owned","clone_into","borrow","borrow_mut","try_from","try_into","type_id","span","from","into","to_owned","clone_into","borrow","borrow_mut","try_from","try_into","type_id","span","from","into","to_owned","clone_into","borrow","borrow_mut","try_from","try_into","type_id","span","from","into","to_owned","clone_into","borrow","borrow_mut","try_from","try_into","type_id","span","from","into","to_owned","clone_into","to_string","borrow","borrow_mut","try_from","try_into","type_id","span","from","into","to_owned","clone_into","to_string","borrow","borrow_mut","try_from","try_into","type_id","span","from","into","to_owned","clone_into","borrow","borrow_mut","try_from","try_into","type_id","from","into","borrow","borrow_mut","try_from","try_into","type_id","span","from","into","to_owned","clone_into","borrow","borrow_mut","try_from","try_into","type_id","from","into","to_owned","clone_into","borrow","borrow_mut","try_from","try_into","type_id","span","from","into","to_owned","clone_into","borrow","borrow_mut","try_from","try_into","type_id","from","into","to_owned","clone_into","borrow","borrow_mut","try_from","try_into","type_id","from","into","to_owned","clone_into","borrow","borrow_mut","try_from","try_into","type_id","from","into","to_owned","clone_into","borrow","borrow_mut","try_from","try_into","type_id","from","into","to_owned","clone_into","borrow","borrow_mut","try_from","try_into","type_id","span","from","into","to_owned","clone_into","borrow","borrow_mut","try_from","try_into","type_id","span","from","into","to_owned","clone_into","borrow","borrow_mut","try_from","try_into","type_id","span","from","into","to_owned","clone_into","borrow","borrow_mut","try_from","try_into","type_id","span","from","into","to_owned","clone_into","borrow","borrow_mut","try_from","try_into","type_id","span","from","into","to_owned","clone_into","borrow","borrow_mut","try_from","try_into","type_id","span","from","into","to_owned","clone_into","borrow","borrow_mut","try_from","try_into","type_id","span","from","into","to_owned","clone_into","borrow","borrow_mut","try_from","try_into","type_id","span","from","into","to_owned","clone_into","borrow","borrow_mut","try_from","try_into","type_id","span","from","into","to_owned","clone_into","borrow","borrow_mut","try_from","try_into","type_id","span","from","into","to_owned","clone_into","borrow","borrow_mut","try_from","try_into","type_id","span","from","into","to_owned","clone_into","borrow","borrow_mut","try_from","try_into","type_id","span","from","into","to_owned","clone_into","borrow","borrow_mut","try_from","try_into","type_id","span","from","into","to_owned","clone_into","borrow","borrow_mut","try_from","try_into","type_id","span","from","into","to_owned","clone_into","borrow","borrow_mut","try_from","try_into","type_id","span","from","into","to_owned","clone_into","borrow","borrow_mut","try_from","try_into","type_id","span","from","into","to_owned","clone_into","borrow","borrow_mut","try_from","try_into","type_id","span","from","into","to_owned","clone_into","borrow","borrow_mut","try_from","try_into","type_id","span","from","into","to_owned","clone_into","borrow","borrow_mut","try_from","try_into","type_id","span","from","into","to_owned","clone_into","borrow","borrow_mut","try_from","try_into","type_id","span","from","into","to_owned","clone_into","borrow","borrow_mut","try_from","try_into","type_id","span","from","into","to_owned","clone_into","borrow","borrow_mut","try_from","try_into","type_id","span","from","into","to_owned","clone_into","borrow","borrow_mut","try_from","try_into","type_id","span","from","into","to_owned","clone_into","borrow","borrow_mut","try_from","try_into","type_id","span","from","into","to_owned","clone_into","borrow","borrow_mut","try_from","try_into","type_id","span","from","into","to_owned","clone_into","borrow","borrow_mut","try_from","try_into","type_id","span","from","into","to_owned","clone_into","borrow","borrow_mut","try_from","try_into","type_id","span","from","into","to_owned","clone_into","borrow","borrow_mut","try_from","try_into","type_id","span","from","into","to_owned","clone_into","borrow","borrow_mut","try_from","try_into","type_id","span","from","into","to_owned","clone_into","borrow","borrow_mut","try_from","try_into","type_id","from","into","to_owned","clone_into","borrow","borrow_mut","try_from","try_into","type_id","from","into","borrow","borrow_mut","try_from","try_into","type_id","from","into","to_owned","clone_into","borrow","borrow_mut","try_from","try_into","type_id","span","from","into","to_owned","clone_into","borrow","borrow_mut","try_from","try_into","type_id","from","into","into_iter","to_owned","clone_into","borrow","borrow_mut","try_from","try_into","type_id","from","into","into_iter","borrow","borrow_mut","try_from","try_into","type_id","from","into","into_iter","to_owned","clone_into","borrow","borrow_mut","try_from","try_into","type_id","from","into","into_iter","to_owned","clone_into","borrow","borrow_mut","try_from","try_into","type_id","from","into","into_iter","to_owned","clone_into","borrow","borrow_mut","try_from","try_into","type_id","from","into","into_iter","borrow","borrow_mut","try_from","try_into","type_id","span","from","into","to_owned","clone_into","borrow","borrow_mut","try_from","try_into","type_id","from","into","borrow","borrow_mut","try_from","try_into","type_id","from","into","to_owned","clone_into","to_string","borrow","borrow_mut","try_from","try_into","type_id","from","into","to_string","borrow","borrow_mut","try_from","try_into","type_id","from","into","to_owned","clone_into","borrow","borrow_mut","try_from","try_into","type_id","from","into","borrow","borrow_mut","try_from","try_into","type_id","eq","eq","hash","cmp","fmt","clone","partial_cmp","fmt","span","fmt","to_tokens","peek","display","peek","display","peek","display","peek","display","peek","display","peek","display","peek","display","peek","display","peek","display","peek","display","peek","display","peek","display","peek","display","peek","display","peek","display","peek","display","peek","display","peek","display","peek","display","peek","display","peek","display","peek","display","peek","display","peek","display","peek","display","peek","display","peek","display","peek","display","peek","display","peek","display","peek","display","peek","display","peek","display","peek","display","peek","display","peek","display","peek","display","peek","display","peek","display","peek","display","peek","display","peek","display","peek","display","peek","display","peek","display","peek","display","peek","display","peek","display","peek","display","peek","display","peek","display","peek","display","peek","display","peek","display","peek","display","peek","display","peek","display","peek","display","peek","display","peek","display","peek","display","peek","display","peek","display","peek","display","peek","display","peek","display","peek","display","peek","display","peek","display","peek","display","peek","display","peek","display","peek","display","peek","display","peek","display","peek","display","peek","display","peek","display","peek","display","peek","display","peek","display","peek","display","peek","display","peek","display","peek","display","peek","display","peek","display","peek","display","peek","display","peek","display","peek","display","peek","display","peek","display","peek","display","peek","display","peek","display","peek","display","peek","display","peek","display","peek","display","peek","display","peek","display","peek","display","peek","display","peek","display","peek","display","peek","display","peek","display","peek","display","peek","display","peek","display","peek","display","peek","display","parse_any","unraw","advance_to","parse","parse","parse","parse","parse","parse","parse","parse","parse","parse","parse","parse","parse","parse","parse","parse","parse","parse","parse","parse","parse","parse","parse","parse","parse","parse","parse","parse","parse","parse","parse","parse","parse","parse","parse","parse","parse","parse","parse","parse","parse","parse","parse","parse","parse","parse","parse","parse","parse","parse","parse","parse","parse","parse","parse","parse","parse","parse","parse","parse","parse","parse","parse","parse","parse","parse","parse","parse","parse","parse","parse","parse","parse","parse","parse","parse","parse","parse","parse","parse","parse","parse","parse","parse","parse","parse","parse","parse","parse","parse","parse","parse","parse","parse","parse","parse","parse","parse","parse","parse","parse","parse","parse","parse","parse","parse","parse","parse","parse","parse","parse","parse","parse","parse","parse","parse","parse","parse","parse","parse","parse","parse","parse","parse","parse","parse","parse","parse","parse","parse","parse","parse","parse","parse","parse","parse","parse","parse","parse","parse","parse","parse","parse","parse","parse","parse","parse","parse","parse","parse","parse","parse","parse","parse","parse","parse","parse","parse","parse","parse","parse","parse","drop","from","from","from","from","from","from","from","from","from","from","from","from","from","from","from","from","from","from","from","from","from","from","from","from","from","from","from","from","from","from","from","from","from","from","from","from","from","from","from","from","from","from","from","from","from","from","from","from","from","from","from","from","from","from","from","from","from","from","from","from","from","from","from","from","from","from","from","from","from","from","from","from","from","from","from","from","from","from","from","from","from","from","from","from","from","from","from","from","from","from","from","from","from","from","from","from","from","next_back","next_back","next_back","next_back","next_back","next_back","len","len","len","len","len","len","extend","extend","extend","into_iter","into_iter","into_iter","next","size_hint","next","size_hint","next","size_hint","next","size_hint","next","size_hint","next","size_hint","clone","clone","clone","clone","clone","clone","clone","clone","clone","clone","clone","clone","clone","clone","clone","clone","clone","clone","clone","clone","clone","clone","clone","clone","clone","clone","clone","clone","clone","clone","clone","clone","clone","clone","clone","clone","clone","clone","clone","clone","clone","clone","clone","clone","clone","clone","clone","clone","clone","clone","clone","clone","clone","clone","clone","clone","clone","clone","clone","clone","clone","clone","clone","clone","clone","clone","clone","clone","clone","clone","clone","clone","clone","clone","clone","clone","clone","clone","clone","clone","clone","clone","clone","clone","clone","clone","clone","clone","clone","clone","clone","clone","clone","clone","clone","clone","clone","clone","clone","clone","clone","clone","clone","clone","clone","clone","clone","clone","clone","clone","clone","clone","clone","clone","clone","clone","clone","clone","clone","clone","clone","clone","clone","clone","clone","clone","clone","clone","clone","clone","clone","clone","clone","clone","clone","clone","clone","clone","clone","clone","clone","clone","clone","clone","clone","clone","clone","clone","clone","clone","clone","clone","clone","clone","clone","clone","clone","clone","clone","clone","clone","clone","clone","clone","clone","clone","clone","clone","clone","clone","clone","clone","clone","clone","clone","clone","clone","clone","clone","clone","clone","clone","clone","clone","clone","clone","clone","clone","clone","clone","clone","clone","clone","clone","clone","clone","clone","clone","clone","clone","clone","clone","default","default","default","default","default","default","default","default","default","default","default","default","default","default","default","default","default","default","default","default","default","default","default","default","default","default","default","default","default","default","default","default","default","default","default","default","default","default","default","default","default","default","default","default","default","default","default","default","default","default","default","default","default","default","default","default","default","default","default","default","default","default","default","default","default","default","default","default","default","default","default","default","default","default","default","default","default","default","default","default","default","default","default","default","default","default","default","default","default","default","default","default","default","default","default","default","default","default","default","default","default","default","default","default","default","default","default","cmp","eq","eq","eq","eq","eq","eq","eq","eq","eq","eq","eq","eq","eq","eq","eq","eq","eq","eq","eq","eq","eq","eq","eq","eq","eq","eq","eq","eq","eq","eq","eq","eq","eq","eq","eq","eq","eq","eq","eq","eq","eq","eq","eq","eq","eq","eq","eq","eq","eq","eq","eq","eq","eq","eq","eq","eq","eq","eq","eq","eq","eq","eq","eq","eq","eq","eq","eq","eq","eq","eq","eq","eq","eq","eq","eq","eq","eq","eq","eq","eq","eq","eq","eq","eq","eq","eq","eq","eq","eq","eq","eq","eq","eq","eq","eq","eq","eq","eq","eq","eq","eq","eq","eq","eq","eq","eq","eq","eq","eq","eq","eq","eq","eq","eq","eq","eq","eq","eq","eq","eq","eq","eq","eq","eq","eq","eq","eq","eq","eq","eq","eq","eq","eq","eq","eq","eq","eq","eq","eq","eq","eq","eq","eq","eq","eq","eq","eq","eq","eq","eq","eq","eq","eq","eq","eq","eq","eq","eq","eq","eq","eq","eq","eq","eq","eq","eq","eq","eq","eq","eq","eq","eq","eq","eq","eq","eq","eq","eq","eq","eq","eq","eq","eq","eq","eq","eq","eq","eq","eq","eq","eq","eq","eq","eq","eq","partial_cmp","deref","deref","deref","deref","deref","deref","deref","deref","deref","deref","deref","deref","deref","deref","deref","deref","deref","deref","deref","deref","deref","deref","deref","deref_mut","deref_mut","deref_mut","deref_mut","deref_mut","deref_mut","deref_mut","deref_mut","deref_mut","deref_mut","deref_mut","deref_mut","deref_mut","deref_mut","deref_mut","deref_mut","deref_mut","deref_mut","deref_mut","deref_mut","deref_mut","deref_mut","fmt","fmt","fmt","fmt","fmt","fmt","fmt","fmt","fmt","fmt","fmt","fmt","fmt","fmt","fmt","fmt","fmt","fmt","fmt","fmt","fmt","fmt","fmt","fmt","fmt","fmt","fmt","fmt","fmt","fmt","fmt","fmt","fmt","fmt","fmt","fmt","fmt","fmt","fmt","fmt","fmt","fmt","fmt","fmt","fmt","fmt","fmt","fmt","fmt","fmt","fmt","fmt","fmt","fmt","fmt","fmt","fmt","fmt","fmt","fmt","fmt","fmt","fmt","fmt","fmt","fmt","fmt","fmt","fmt","fmt","fmt","fmt","fmt","fmt","fmt","fmt","fmt","fmt","fmt","fmt","fmt","fmt","fmt","fmt","fmt","fmt","fmt","fmt","fmt","fmt","fmt","fmt","fmt","fmt","fmt","fmt","fmt","fmt","fmt","fmt","fmt","fmt","fmt","fmt","fmt","fmt","fmt","fmt","fmt","fmt","fmt","fmt","fmt","fmt","fmt","fmt","fmt","fmt","fmt","fmt","fmt","fmt","fmt","fmt","fmt","fmt","fmt","fmt","fmt","fmt","fmt","fmt","fmt","fmt","fmt","fmt","fmt","fmt","fmt","fmt","fmt","fmt","fmt","fmt","fmt","fmt","fmt","fmt","fmt","fmt","fmt","fmt","fmt","fmt","fmt","fmt","fmt","fmt","fmt","fmt","fmt","fmt","fmt","fmt","fmt","fmt","fmt","fmt","fmt","fmt","fmt","fmt","fmt","fmt","fmt","fmt","fmt","fmt","fmt","fmt","fmt","fmt","fmt","fmt","fmt","fmt","fmt","fmt","fmt","fmt","fmt","fmt","fmt","fmt","fmt","fmt","fmt","fmt","fmt","fmt","fmt","index","index_mut","hash","hash","hash","hash","hash","hash","hash","hash","hash","hash","hash","hash","hash","hash","hash","hash","hash","hash","hash","hash","hash","hash","hash","hash","hash","hash","hash","hash","hash","hash","hash","hash","hash","hash","hash","hash","hash","hash","hash","hash","hash","hash","hash","hash","hash","hash","hash","hash","hash","hash","hash","hash","hash","hash","hash","hash","hash","hash","hash","hash","hash","hash","hash","hash","hash","hash","hash","hash","hash","hash","hash","hash","hash","hash","hash","hash","hash","hash","hash","hash","hash","hash","hash","hash","hash","hash","hash","hash","hash","hash","hash","hash","hash","hash","hash","hash","hash","hash","hash","hash","hash","hash","hash","hash","hash","hash","hash","hash","hash","hash","hash","hash","hash","hash","hash","hash","hash","hash","hash","hash","hash","hash","hash","hash","hash","hash","hash","hash","hash","hash","hash","hash","hash","hash","hash","hash","hash","hash","hash","hash","hash","hash","hash","hash","hash","hash","hash","hash","hash","hash","hash","hash","hash","hash","hash","hash","hash","hash","hash","hash","hash","hash","hash","hash","hash","hash","hash","hash","hash","hash","hash","hash","hash","hash","hash","hash","hash","hash","hash","hash","hash","hash","hash","hash","hash","hash","hash","hash","hash","hash","hash","hash","hash","hash","from_iter","from_iter","to_tokens","to_tokens","to_tokens","to_tokens","to_tokens","to_tokens","to_tokens","to_tokens","to_tokens","to_tokens","to_tokens","to_tokens","to_tokens","to_tokens","to_tokens","to_tokens","to_tokens","to_tokens","to_tokens","to_tokens","to_tokens","to_tokens","to_tokens","to_tokens","to_tokens","to_tokens","to_tokens","to_tokens","to_tokens","to_tokens","to_tokens","to_tokens","to_tokens","to_tokens","to_tokens","to_tokens","to_tokens","to_tokens","to_tokens","to_tokens","to_tokens","to_tokens","to_tokens","to_tokens","to_tokens","to_tokens","to_tokens","to_tokens","to_tokens","to_tokens","to_tokens","to_tokens","to_tokens","to_tokens","to_tokens","to_tokens","to_tokens","to_tokens","to_tokens","to_tokens","to_tokens","to_tokens","to_tokens","to_tokens","to_tokens","to_tokens","to_tokens","to_tokens","to_tokens","to_tokens","to_tokens","to_tokens","to_tokens","to_tokens","to_tokens","to_tokens","to_tokens","to_tokens","to_tokens","to_tokens","to_tokens","to_tokens","to_tokens","to_tokens","to_tokens","to_tokens","to_tokens","to_tokens","to_tokens","to_tokens","to_tokens","to_tokens","to_tokens","to_tokens","to_tokens","to_tokens","to_tokens","to_tokens","to_tokens","to_tokens","to_tokens","to_tokens","to_tokens","to_tokens","to_tokens","to_tokens","to_tokens","to_tokens","to_tokens","to_tokens","to_tokens","to_tokens","to_tokens","to_tokens","to_tokens","to_tokens","to_tokens","to_tokens","to_tokens","to_tokens","to_tokens","to_tokens","to_tokens","to_tokens","to_tokens","to_tokens","to_tokens","to_tokens","to_tokens","to_tokens","to_tokens","to_tokens","to_tokens","to_tokens","to_tokens","to_tokens","to_tokens","to_tokens","to_tokens","to_tokens","to_tokens","to_tokens","to_tokens","to_tokens","to_tokens","to_tokens","to_tokens","to_tokens","to_tokens","to_tokens","to_tokens","to_tokens","to_tokens","to_tokens","to_tokens","to_tokens","to_tokens","to_tokens","to_tokens","to_tokens","to_tokens","to_tokens","to_tokens","to_tokens","to_tokens","to_tokens","to_tokens","to_tokens","to_tokens","to_tokens","to_tokens","to_tokens","to_tokens","to_tokens","to_tokens","to_tokens","to_tokens","to_tokens","to_tokens","to_tokens","to_tokens","to_tokens","to_tokens","to_tokens","to_tokens","to_tokens","to_tokens","to_tokens","to_tokens","to_tokens","to_tokens","to_tokens","to_tokens","to_tokens","to_tokens","to_tokens","to_tokens","to_tokens","to_tokens","to_tokens","to_tokens","to_tokens","to_tokens","to_tokens","to_tokens","to_tokens","to_tokens","to_tokens","to_tokens","to_tokens","to_tokens","to_tokens","to_tokens","to_tokens","fmt","span","fmt","span","new","span","set_span","parse_meta","parse_args","parse_args_with","parse_outer","parse_inner","path","parse_named","parse_unnamed","iter","iter_mut","len","is_empty","type_params","type_params_mut","lifetimes","lifetimes_mut","const_params","const_params_mut","make_where_clause","split_for_impl","as_turbofish","new","new","span","set_span","new","suffix","span","set_span","new","value","parse","parse_with","span","set_span","suffix","new","value","span","set_span","suffix","new","value","span","set_span","suffix","new","value","span","set_span","suffix","new","base10_digits","base10_parse","suffix","span","set_span","new","base10_digits","base10_parse","suffix","span","set_span","new","value","span","set_span","parse_body","parse_body_with","without_plus","without_plus","without_plus","parse_mod_style","is_ident","get_ident","is_empty","visit_abi","visit_angle_bracketed_generic_arguments","visit_attr_style","visit_attribute","visit_bare_fn_arg","visit_bin_op","visit_binding","visit_bound_lifetimes","visit_const_param","visit_constraint","visit_data","visit_data_enum","visit_data_struct","visit_data_union","visit_derive_input","visit_expr","visit_expr_binary","visit_expr_call","visit_expr_cast","visit_expr_field","visit_expr_index","visit_expr_lit","visit_expr_paren","visit_expr_path","visit_expr_unary","visit_field","visit_fields","visit_fields_named","visit_fields_unnamed","visit_generic_argument","visit_generic_param","visit_generics","visit_ident","visit_index","visit_lifetime","visit_lifetime_def","visit_lit","visit_lit_bool","visit_lit_byte","visit_lit_byte_str","visit_lit_char","visit_lit_float","visit_lit_int","visit_lit_str","visit_macro","visit_macro_delimiter","visit_member","visit_meta","visit_meta_list","visit_meta_name_value","visit_nested_meta","visit_parenthesized_generic_arguments","visit_path","visit_path_arguments","visit_path_segment","visit_predicate_eq","visit_predicate_lifetime","visit_predicate_type","visit_qself","visit_return_type","visit_span","visit_trait_bound","visit_trait_bound_modifier","visit_type","visit_type_array","visit_type_bare_fn","visit_type_group","visit_type_impl_trait","visit_type_infer","visit_type_macro","visit_type_never","visit_type_param","visit_type_param_bound","visit_type_paren","visit_type_path","visit_type_ptr","visit_type_reference","visit_type_slice","visit_type_trait_object","visit_type_tuple","visit_un_op","visit_variadic","visit_variant","visit_vis_crate","visit_vis_public","visit_vis_restricted","visit_visibility","visit_where_clause","visit_where_predicate","peek","error"],"q":["syn","syn::token","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","syn","syn::buffer","","","","","","","","","","","","","","","syn","syn::ext","","","","syn","syn::punctuated","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","syn","syn::spanned","","syn","syn::visit","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","syn","syn::parse","syn::parse::discouraged","","syn::parse","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","syn","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","syn::token","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","syn","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","syn::buffer","","","","","","","","","","","","","","","","syn::punctuated","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","syn::parse","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","syn","","","","","","","","","","","","","","","","","","","","","","","","","","","","","syn::token","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","syn","","","","syn::parse","syn::token","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","syn","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","syn::parse","","syn","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","syn::parse","syn::punctuated","","","","","","","","","","","","","","syn::parse","syn","syn::punctuated","syn::parse","syn::punctuated","","","","","","","","","","","","syn::token","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","syn","","","","","","","","","","syn::buffer","syn::punctuated","","","","","","syn","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","syn::parse","","syn::token","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","syn","","","syn::punctuated","syn","syn::token","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","syn","","","","","","","","","","","","syn::buffer","syn::punctuated","syn","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","syn::token","","","","","","","","","","","","","","","","","","","","","","syn::parse","syn::token","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","syn","","","","","","","","","","syn::punctuated","syn","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","syn::parse","","syn","","","syn::parse","","syn::punctuated","","syn::token","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","syn","","","","","","","","","","","","syn::punctuated","syn","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","syn::punctuated","","syn::token","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","syn","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","syn::punctuated","","syn","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","syn::visit","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","syn::parse",""],"d":["Tokens representing Rust punctuation, keywords, and …","Marker trait for types that represent single tokens.","_","","abstract","","as","","async","","auto","","await","","become","","box","","break","","const","","continue","","crate","","default","","do","","dyn","","else","","enum","","extern","","final","","fn","","for","","if","","impl","","in","","let","","loop","","macro","","match","","mod","","move","","mut","","override","","priv","","pub","","ref","","return","","Self","","self","","static","","struct","","super","","trait","","try","","type","","typeof","","union","","unsafe","","unsized","","use","","virtual","","where","","while","","yield","","+","","+=","","&","","&&","","&=","","@","","!","","^","","^=","",":","","::","",",","","/","","/=","","$","",".","","..","","...","","..=","","=","","==","",">=","",">","","<=","","<","","*=","","!=","","|","","|=","","||","","#","","?","","->","","<-","","%","","%=","","=>","",";","","<<","","<<=","",">>","",">>=","","*","","-","","-=","","~","","{...}","","","[...]","","","(...)","","","None-delimited group","","","A stably addressed token buffer supporting efficient …","A buffer that can be efficiently traversed multiple …","Creates a TokenBuffer containing all the tokens from the …","Creates a TokenBuffer containing all the tokens from the …","Creates a cursor referencing the first token in the …","A cheaply copyable cursor into a TokenBuffer.","Creates a cursor referencing a static empty TokenStream.","Checks whether the cursor is currently pointing at the …","If the cursor is pointing at a Group with the given …","If the cursor is pointing at a Ident, returns it along …","If the cursor is pointing at an Punct, returns it along …","If the cursor is pointing at a Literal, return it along …","If the cursor is pointing at a Lifetime, returns it along …","Copies all remaining tokens visible from this cursor into …","If the cursor is pointing at a TokenTree, returns it …","Returns the Span of the current token, or …","Extension traits to provide parsing methods on foreign …","Additional methods for Ident not provided by proc-macro2 …","Parses any identifier including keywords.","Peeks any identifier including keywords. Usage: …","Strips the raw marker r#, if any, from the beginning of …","A punctuated sequence of syntax tree nodes separated by …","A punctuated sequence of syntax tree nodes of type T …","Creates an empty punctuated sequence.","Determines whether this punctuated sequence is empty, …","Returns the number of syntax tree nodes in this …","Borrows the first element in this sequence.","Mutably borrows the first element in this sequence.","Borrows the last element in this sequence.","Mutably borrows the last element in this sequence.","Returns an iterator over borrowed syntax tree nodes of …","Returns an iterator over mutably borrowed syntax tree …","Returns an iterator over the contents of this sequence as …","Returns an iterator over the contents of this sequence as …","Returns an iterator over the contents of this sequence as …","Appends a syntax tree node onto the end of this …","Appends a trailing punctuation onto the end of this …","Removes the last punctuated pair from this sequence, or …","Determines whether this punctuated sequence ends with a …","Returns true if either this Punctuated is empty, or it …","Appends a syntax tree node onto the end of this …","Inserts an element at position index.","Clears the sequence of all values and punctuation, making …","Parses zero or more occurrences of T separated by …","Parses zero or more occurrences of T using the given …","Parses one or more occurrences of T separated by …","Parses one or more occurrences of T using the given parse …","An iterator over borrowed pairs of type Pair<&T, &P>.","An iterator over mutably borrowed pairs of type …","An iterator over owned pairs of type Pair.","An iterator over owned values of type T.","An iterator over borrowed values of type &T.","An iterator over mutably borrowed values of type &mut T.","A single syntax tree node of type T followed by its …","","","Extracts the syntax tree node from this punctuated pair, …","Borrows the syntax tree node from this punctuated pair.","Mutably borrows the syntax tree node from this punctuated …","Borrows the punctuation from this punctuated pair, unless …","Creates a punctuated pair out of a syntax tree node and …","Produces this punctuated pair as a tuple of syntax tree …","A trait that can provide the Span of the complete …","A trait that can provide the Span of the complete …","Returns a Span covering the complete contents of this …","Syntax tree traversal to walk a shared borrow of a syntax …","Syntax tree traversal to walk a shared borrow of a syntax …","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","Parsing interface for parsing a token stream into a …","Extensions to the parsing API with niche applicability.","Extensions to the ParseStream API to support speculative …","Advance this parse stream to the position of a forked …","Error returned when a Syn parser cannot parse the input …","The result of a Syn parser.","Support for checking the next token in a stream to decide …","Types that can be parsed by looking at just one token.","Parsing interface implemented by all types that can be …","","Input to a Syn parser function.","Cursor position within a buffered token stream.","Cursor state associated with speculative parsing.","Triggers an error at the current position of the parse …","Parses a syntax tree node of type T, advancing the …","Calls the given parser function to parse a syntax tree …","Looks at the next token in the parse stream to determine …","Looks at the second-next token in the parse stream.","Looks at the third-next token in the parse stream.","Parses zero or more occurrences of T separated by …","Returns whether there are tokens remaining in this stream.","Constructs a helper for peeking at the next token in this …","Forks a parse stream so that parsing tokens out of either …","Triggers an error at the current position of the parse …","Speculatively parses tokens from this parse stream, …","Returns the Span of the next token in the parse stream, or…","Provides low-level access to the token representation …","Parser that can parse Rust tokens into a particular …","","Parse a proc-macro2 token stream into the chosen syntax …","Parse tokens of source code into the chosen syntax tree …","Parse a string of Rust code into the chosen syntax tree …","An empty syntax tree node that consumes no tokens when …","Usually the ParseStream::error method will be used …","Creates an error with the specified message spanning the …","The source location of the error.","Render the error as an invocation of compile_error!.","Render the error as an invocation of compile_error!.","Add another error message to self such that when …","A word of Rust code, which may be a keyword or legal …","Distinguishes between attributes that decorate an item …","","","An attribute like #[repr(transparent)].","","","","","","Conventional argument type associated with an invocation …","Content of a compile-time structured attribute.","","A structured list within an attribute, like …","A name-value pair within an attribute, like …","A structured list within an attribute, like …","","","","A name-value pair within an attribute, like …","","","","Element of a compile-time attribute list.","A structured meta item, like the Copy in #[derive(Copy)] …","A Rust literal, like the \\\"new_name\\\" in …","A field of a struct or enum variant.","Attributes tagged on the field.","Visibility of the field.","Name of the field, if any.","","Type of the field.","Data stored within an enum variant or struct.","Named fields of a struct or struct variant such as …","Unnamed fields of a tuple struct or tuple variant such as …","Unit struct or unit variant such as None.","Named fields of a struct or struct variant such as …","","","Unnamed fields of a tuple struct or tuple variant such as …","","","An enum variant.","Attributes tagged on the variant.","Name of the variant.","Content stored in the variant.","Explicit discriminant: Variant = 1","A crate-level visibility: crate.","","A public visibility level: pub.","","A visibility level restricted to some path: pub(self) or …","","","","","The visibility level of an item: inherited or pub or …","A public visibility level: pub.","A crate-level visibility: crate.","A visibility level restricted to some path: pub(self) or …","An inherited visibility, which usually means private.","A Rust expression.","A slice literal expression: [a, b, c, d].","An assignment expression: a = compute().","A compound assignment expression: counter += 1.","An async block: async { ... }.","An await expression: fut.await.","A binary operation: a + b, a * b.","A blocked scope: { ... }.","A box expression: box f.","A break, with an optional label to break and an optional …","A function call expression: invoke(a, b).","A cast expression: foo as f64.","A closure expression: |a, b| a + b.","A continue, with an optional label.","Access of a named struct field (obj.k) or unnamed tuple …","A for loop: for pat in expr { ... }.","An expression contained within invisible delimiters.","An if expression with an optional else block: …","A square bracketed indexing expression: vector[2].","A let guard: let Some(x) = opt.","A literal in place of an expression: 1, \\\"foo\\\".","Conditionless loop: loop { ... }.","A macro invocation expression: format!(\\\"{}\\\", q).","A match expression: match n { Some(n) => {}, None => {} }.","A method call expression: x.foo::(a, b).","A parenthesized expression: (a + b).","A path like std::mem::replace possibly containing generic …","A range expression: 1..2, 1.., ..2, 1..=2, ..=2.","A referencing operation: &a or &mut a.","An array literal constructed from one repeated element: …","A return, with an optional value to be returned.","A struct literal expression: Point { x: 1, y: 1 }.","A try-expression: expr?.","A try block: try { ... }.","A tuple expression: (a, b, c, d).","A type ascription expression: foo: f64.","A unary operation: !x, *x.","An unsafe block: unsafe { ... }.","Tokens in expression position not interpreted by Syn.","A while loop: while expr { ... }.","A yield expression: yield expr.","A slice literal expression: [a, b, c, d].","An assignment expression: a = compute().","A compound assignment expression: counter += 1.","An async block: async { ... }.","An await expression: fut.await.","A binary operation: a + b, a * b.","","","","","A blocked scope: { ... }.","A box expression: box f.","A break, with an optional label to break and an optional …","A function call expression: invoke(a, b).","","","","","A cast expression: foo as f64.","","","","","A closure expression: |a, b| a + b.","A continue, with an optional label.","Access of a named struct field (obj.k) or unnamed tuple …","","","","","A for loop: for pat in expr { ... }.","An expression contained within invisible delimiters.","An if expression with an optional else block: …","A square bracketed indexing expression: vector[2].","","","","","A let guard: let Some(x) = opt.","A literal in place of an expression: 1, \\\"foo\\\".","","","Conditionless loop: loop { ... }.","A macro invocation expression: format!(\\\"{}\\\", q).","A match expression: match n { Some(n) => {}, None => {} }.","A method call expression: x.foo::(a, b).","A parenthesized expression: (a + b).","","","","A path like std::mem::replace possibly containing generic …","","","","A range expression: 1..2, 1.., ..2, 1..=2, ..=2.","A referencing operation: &a or &mut a.","An array literal constructed from one repeated element: …","A return, with an optional value to be returned.","A struct literal expression: Point { x: 1, y: 1 }.","A try-expression: expr?.","A try block: try { ... }.","A tuple expression: (a, b, c, d).","A type ascription expression: foo: f64.","A unary operation: !x, *x.","","","","An unsafe block: unsafe { ... }.","A while loop: while expr { ... }.","A yield expression: yield expr.","The index of an unnamed tuple struct field.","","","A struct or tuple struct field accessed in a struct …","A named field like self.x.","An unnamed field like self.0.","A set of bound lifetimes: for<\'a, \'b, \'c>.","","","","","A const generic parameter: const LENGTH: usize.","","","","","","","","A generic type parameter, lifetime, or const generic: …","A generic type parameter: T: Into.","A lifetime definition: \'a: \'b + \'c + \'d.","A const generic parameter: const LENGTH: usize.","Lifetimes and type parameters attached to a declaration …","","","","","A lifetime definition: \'a: \'b + \'c + \'d.","","","","","An equality predicate in a where clause (unsupported).","","","","A lifetime predicate in a where clause: \'a: \'b + \'c.","","","","A type predicate in a where clause: …","Any lifetimes from a for binding","The type being bounded","","Trait and lifetime bounds (Clone+Send+\'static)","A trait used as a bound on a type parameter.","","","The for<\'a> in for<\'a> Foo<&\'a T>","The Foo<&\'a T> in for<\'a> Foo<&\'a T>","A modifier on a trait bound, currently only used for the ?…","","","A generic type parameter: T: Into.","","","","","","","A trait or lifetime used as a bound on a type parameter.","","","A where clause in a definition: …","","","A single predicate in a where clause: T: Deserialize<\'de>.","A type predicate in a where clause: …","A lifetime predicate in a where clause: \'a: \'b + \'c.","An equality predicate in a where clause (unsupported).","Returned by Generics::split_for_impl.","Returned by TypeGenerics::as_turbofish.","Returned by Generics::split_for_impl.","A Rust lifetime: \'a.","","","A Rust literal such as a string or integer or boolean.","A UTF-8 string literal: \\\"foo\\\".","A byte string literal: b\\\"foo\\\".","A byte literal: b\'f\'.","A character literal: \'a\'.","An integer literal: 1 or 1u16.","A floating point literal: 1f64 or 1.0e10f64.","A boolean literal: true or false.","A raw token literal not interpreted by Syn.","A boolean literal: true or false.","","","A byte literal: b\'f\'.","A byte string literal: b\\\"foo\\\".","A character literal: \'a\'.","A floating point literal: 1f64 or 1.0e10f64.","An integer literal: 1 or 1u16.","A UTF-8 string literal: \\\"foo\\\".","The style of a string literal, either plain quoted or a …","An ordinary string like \\\"data\\\".","A raw string like r##\\\"data\\\"##.","A macro invocation: println!(\\\"{}\\\", mac).","","","","","A grouping token that surrounds a macro body: m!(...) or …","","","","The storage of a struct, enum or union data structure.","A struct input to a proc_macro_derive macro.","An enum input to a proc_macro_derive macro.","An untagged union input to a proc_macro_derive macro.","An enum input to a proc_macro_derive macro.","","","","A struct input to a proc_macro_derive macro.","","","","An untagged union input to a proc_macro_derive macro.","","","Data structure sent to a proc_macro_derive macro.","Attributes tagged on the whole struct or enum.","Visibility of the struct or enum.","Name of the struct or enum.","Generics required to complete the definition.","Data within the struct or enum.","A binary operator: +, +=, &.","The + operator (addition)","The - operator (subtraction)","The * operator (multiplication)","The / operator (division)","The % operator (modulus)","The && operator (logical and)","The || operator (logical or)","The ^ operator (bitwise xor)","The & operator (bitwise and)","The | operator (bitwise or)","The << operator (shift left)","The >> operator (shift right)","The == operator (equality)","The < operator (less than)","The <= operator (less than or equal to)","The != operator (not equal to)","The >= operator (greater than or equal to)","The > operator (greater than)","The += operator","The -= operator","The *= operator","The /= operator","The %= operator","The ^= operator","The &= operator","The |= operator","The <<= operator","The >>= operator","A unary operator: *, !, -.","The * operator for dereferencing","The ! operator for logical inversion","The - operator for negation","The binary interface of a function: extern \\\"C\\\".","","","An argument in a function type: the usize in …","","","","Return type of a function signature.","Return type is not specified.","A particular type is returned.","The possible types that a Rust value could have.","A fixed size array type: [T; n].","A bare function type: fn(usize) -> bool.","A type contained within invisible delimiters.","An impl Bound1 + Bound2 + Bound3 type where Bound is a …","Indication that a type should be inferred by the …","A macro in the type position.","The never type: !.","A parenthesized type equivalent to the inner type.","A path like std::slice::Iter, optionally qualified with a …","A raw pointer type: *const T or *mut T.","A reference type: &\'a T or &\'a mut T.","A dynamically sized slice type: [T].","A trait object type Bound1 + Bound2 + Bound3 where Bound …","A tuple type: (A, B, C, String).","Tokens in type position not interpreted by Syn.","A fixed size array type: [T; n].","","","","","A bare function type: fn(usize) -> bool.","","","","","","","","","A type contained within invisible delimiters.","","","An impl Bound1 + Bound2 + Bound3 type where Bound is a …","","","Indication that a type should be inferred by the …","","A macro in the type position.","","The never type: !.","","A parenthesized type equivalent to the inner type.","","","A path like std::slice::Iter, optionally qualified with a …","","","A raw pointer type: *const T or *mut T.","","","","","A reference type: &\'a T or &\'a mut T.","","","","","A dynamically sized slice type: [T].","","","A trait object type Bound1 + Bound2 + Bound3 where Bound …","","","A tuple type: (A, B, C, String).","","","The variadic argument of a foreign function.","","","Angle bracketed arguments of a path segment: the …","","","","","A binding (equality constraint) on an associated type: …","","","","An associated type bound: Iterator.","","","","An individual generic argument, like \'a, T, or Item = T.","A lifetime argument.","A type argument.","A binding (equality constraint) on an associated type: …","An associated type bound: Iterator.","A const expression. Must be inside of a block.","Arguments of a function path segment: the (A, B) -> C in …","","(A, B)","C","A path at which a named item is exported (e.g. …","","","Angle bracketed or parenthesized arguments of a path …","","The <\'a, T> in std::slice::iter<\'a, T>.","The (A, B) -> C in Fn(A, B) -> C.","A segment of a path together with any path arguments on …","","","The explicit Self type in a qualified path: the T in …","","","","","","Error returned when a Syn parser cannot parse the input …","The result of a Syn parser.","Parse tokens of source code into the chosen syntax tree …","Parse a proc-macro2 token stream into the chosen syntax …","Parse a string of Rust code into the chosen syntax tree …","Parse a set of parentheses and expose their content to …","Parse a set of curly braces and expose their content to …","Parse a set of square brackets and expose their content …","A type-macro that expands to the name of the Rust type …","Quasi-quotation macro that accepts input like the quote! …","Parse the input TokenStream of a macro, triggering a …","Define a type that supports parsing and printing a given …","Define a type that supports parsing and printing a …","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","Creates a new Ident with the given string as well as the …","Returns the span of this Ident.","Configures the span of this Ident, possibly changing its …","Parses the content of the attribute, consisting of the …","Parse the arguments to the attribute as a syntax tree.","Parse the arguments to the attribute using the given …","Parses zero or more outer attributes from the stream.","Parses zero or more inner attributes from the stream.","Returns the identifier that begins this structured meta …","Parses a named (braced struct) field.","Parses an unnamed (tuple struct) field.","Get an iterator over the borrowed [Field] items in this …","Get an iterator over the mutably borrowed [Field] items …","Returns the number of fields.","Returns true if there are zero fields.","Returns an Iterator over the type …","Returns an Iterator over the type …","Returns an Iterator over the …","Returns an Iterator over the …","Returns an Iterator over the constant …","Returns an Iterator over the …","Initializes an empty where-clause if there is not one …","Split a type’s generics into the pieces required for …","Turn a type’s generics like into a turbofish …","","Panics","","","Interpret a Syn literal from a proc-macro2 literal.","","","","","","Parse a syntax tree node from the content of this string …","Invoke parser on the content of this string literal.","","","","","","","","","","","","","","","","","","","","","Parses the literal into a selected number type.","","","","","","","","","","","","","","Parse the tokens within the macro invocation’s …","Parse the tokens within the macro invocation’s …","In some positions, types may not contain the + character, …","","","Parse a Path containing no path arguments on any of its …","Determines whether this is a path of length 1 equal to …","If this path consists of a single ident, returns the …","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","Looks at the next token in the parse stream to determine …","Triggers an error at the current position of the parse …"],"i":[0,0,0,1,0,2,0,3,0,4,0,5,0,6,0,7,0,8,0,9,0,10,0,11,0,12,0,13,0,14,0,15,0,16,0,17,0,18,0,19,0,20,0,21,0,22,0,23,0,24,0,25,0,26,0,27,0,28,0,29,0,30,0,31,0,32,0,33,0,34,0,35,0,36,0,37,0,38,0,39,0,40,0,41,0,42,0,43,0,44,0,45,0,46,0,47,0,48,0,49,0,50,0,51,0,52,0,53,0,54,0,55,0,56,0,57,0,58,0,59,0,60,0,61,0,62,0,63,0,64,0,65,0,66,0,67,0,68,0,69,0,70,0,71,0,72,0,73,0,74,0,75,0,76,0,77,0,78,0,79,0,80,0,81,0,82,0,83,0,84,0,85,0,86,0,87,0,88,0,89,0,90,0,91,0,92,0,93,0,94,0,95,0,96,0,97,0,98,0,99,0,100,100,0,101,101,0,102,102,0,103,103,0,0,104,104,104,0,105,105,105,105,105,105,105,105,105,105,0,0,106,106,106,0,0,107,107,107,107,107,107,107,107,107,107,107,107,107,107,107,107,107,107,107,107,107,107,107,107,0,0,0,0,0,0,0,108,108,108,108,108,108,108,108,0,0,109,0,0,110,110,110,110,110,110,110,110,110,110,110,110,110,110,110,110,110,110,110,110,110,110,110,110,110,110,110,110,110,110,110,110,110,110,110,110,110,110,110,110,110,110,110,110,110,110,110,110,110,110,110,110,110,110,110,110,110,110,110,110,110,110,110,110,110,110,110,110,110,110,110,110,110,110,110,110,110,110,110,110,110,110,110,110,110,110,110,110,110,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,111,0,0,0,0,0,112,0,0,0,113,114,114,114,114,114,114,114,114,114,114,114,114,114,0,115,115,115,115,0,116,116,116,116,116,116,0,0,117,117,0,118,118,118,118,118,0,0,119,119,119,0,120,120,120,0,121,121,121,0,122,122,0,123,123,123,123,123,0,124,124,124,0,125,125,0,126,126,0,127,127,127,127,0,128,0,129,0,130,130,130,130,0,131,131,131,131,0,132,132,132,132,132,132,132,132,132,132,132,132,132,132,132,132,132,132,132,132,132,132,132,132,132,132,132,132,132,132,132,132,132,132,132,132,132,132,132,132,0,0,0,0,0,0,133,133,133,133,0,0,0,0,134,134,134,134,0,135,135,135,135,0,0,0,136,136,136,136,0,0,0,0,137,137,137,137,0,0,138,138,0,0,0,0,0,139,139,139,0,140,140,140,0,0,0,0,0,0,0,0,0,0,141,141,141,0,0,0,0,142,142,0,143,143,0,144,144,144,144,0,145,145,145,145,145,145,145,0,146,146,146,0,147,147,147,147,0,148,148,148,148,0,149,149,149,0,150,150,150,0,151,151,151,151,0,152,152,152,152,0,153,153,0,154,154,154,154,154,154,0,155,155,0,156,156,0,157,157,157,0,0,0,0,158,158,0,159,159,159,159,159,159,159,159,0,160,160,0,0,0,0,0,0,0,161,161,0,162,162,162,162,0,163,163,163,0,164,164,164,0,165,165,165,0,166,166,166,0,167,167,0,168,168,168,168,168,0,169,169,169,169,169,169,169,169,169,169,169,169,169,169,169,169,169,169,169,169,169,169,169,169,169,169,169,169,0,170,170,170,0,171,171,0,172,172,172,0,173,173,0,174,174,174,174,174,174,174,174,174,174,174,174,174,174,174,0,175,175,175,175,0,176,176,176,176,176,176,176,176,0,177,177,0,178,178,0,179,0,180,0,181,0,182,182,0,183,183,0,184,184,184,184,0,185,185,185,185,0,186,186,0,187,187,0,188,188,0,189,189,0,190,190,190,190,0,191,191,191,0,192,192,192,0,193,193,193,193,193,0,194,194,194,0,195,195,0,196,196,196,0,197,197,0,198,198,198,198,198,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,2,2,2,2,2,2,2,2,2,2,3,3,3,3,3,3,3,3,3,3,4,4,4,4,4,4,4,4,4,4,5,5,5,5,5,5,5,5,5,5,6,6,6,6,6,6,6,6,6,6,7,7,7,7,7,7,7,7,7,7,8,8,8,8,8,8,8,8,8,8,9,9,9,9,9,9,9,9,9,9,10,10,10,10,10,10,10,10,10,10,11,11,11,11,11,11,11,11,11,11,12,12,12,12,12,12,12,12,12,12,13,13,13,13,13,13,13,13,13,13,14,14,14,14,14,14,14,14,14,14,15,15,15,15,15,15,15,15,15,15,16,16,16,16,16,16,16,16,16,16,17,17,17,17,17,17,17,17,17,17,18,18,18,18,18,18,18,18,18,18,19,19,19,19,19,19,19,19,19,19,20,20,20,20,20,20,20,20,20,20,21,21,21,21,21,21,21,21,21,21,22,22,22,22,22,22,22,22,22,22,23,23,23,23,23,23,23,23,23,23,24,24,24,24,24,24,24,24,24,24,25,25,25,25,25,25,25,25,25,25,26,26,26,26,26,26,26,26,26,26,27,27,27,27,27,27,27,27,27,27,28,28,28,28,28,28,28,28,28,28,29,29,29,29,29,29,29,29,29,29,30,30,30,30,30,30,30,30,30,30,31,31,31,31,31,31,31,31,31,31,32,32,32,32,32,32,32,32,32,32,33,33,33,33,33,33,33,33,33,33,34,34,34,34,34,34,34,34,34,34,35,35,35,35,35,35,35,35,35,35,36,36,36,36,36,36,36,36,36,36,37,37,37,37,37,37,37,37,37,37,38,38,38,38,38,38,38,38,38,38,39,39,39,39,39,39,39,39,39,39,40,40,40,40,40,40,40,40,40,40,41,41,41,41,41,41,41,41,41,41,42,42,42,42,42,42,42,42,42,42,43,43,43,43,43,43,43,43,43,43,44,44,44,44,44,44,44,44,44,44,45,45,45,45,45,45,45,45,45,45,46,46,46,46,46,46,46,46,46,46,47,47,47,47,47,47,47,47,47,47,48,48,48,48,48,48,48,48,48,48,49,49,49,49,49,49,49,49,49,49,50,50,50,50,50,50,50,50,50,50,51,51,51,51,51,51,51,51,51,51,52,52,52,52,52,52,52,52,52,52,53,53,53,53,53,53,53,53,53,53,54,54,54,54,54,54,54,54,54,54,55,55,55,55,55,55,55,55,55,55,56,56,56,56,56,56,56,56,56,56,57,57,57,57,57,57,57,57,57,57,58,58,58,58,58,58,58,58,58,58,59,59,59,59,59,59,59,59,59,59,60,60,60,60,60,60,60,60,60,60,61,61,61,61,61,61,61,61,61,61,62,62,62,62,62,62,62,62,62,62,63,63,63,63,63,63,63,63,63,63,64,64,64,64,64,64,64,64,64,64,65,65,65,65,65,65,65,65,65,65,66,66,66,66,66,66,66,66,66,66,67,67,67,67,67,67,67,67,67,67,68,68,68,68,68,68,68,68,68,68,69,69,69,69,69,69,69,69,69,69,70,70,70,70,70,70,70,70,70,70,71,71,71,71,71,71,71,71,71,71,72,72,72,72,72,72,72,72,72,72,73,73,73,73,73,73,73,73,73,73,74,74,74,74,74,74,74,74,74,74,75,75,75,75,75,75,75,75,75,75,76,76,76,76,76,76,76,76,76,76,77,77,77,77,77,77,77,77,77,77,78,78,78,78,78,78,78,78,78,78,79,79,79,79,79,79,79,79,79,79,80,80,80,80,80,80,80,80,80,80,81,81,81,81,81,81,81,81,81,81,82,82,82,82,82,82,82,82,82,82,83,83,83,83,83,83,83,83,83,83,84,84,84,84,84,84,84,84,84,84,85,85,85,85,85,85,85,85,85,85,86,86,86,86,86,86,86,86,86,86,87,87,87,87,87,87,87,87,87,87,88,88,88,88,88,88,88,88,88,88,89,89,89,89,89,89,89,89,89,89,90,90,90,90,90,90,90,90,90,90,91,91,91,91,91,91,91,91,91,91,92,92,92,92,92,92,92,92,92,92,93,93,93,93,93,93,93,93,93,93,94,94,94,94,94,94,94,94,94,94,95,95,95,95,95,95,95,95,95,95,96,96,96,96,96,96,96,96,96,96,97,97,97,97,97,97,97,97,97,97,98,98,98,98,98,98,98,98,98,98,99,99,99,99,99,99,99,99,99,99,100,100,100,100,100,100,100,100,100,101,101,101,101,101,101,101,101,101,102,102,102,102,102,102,102,102,102,103,103,103,103,103,103,103,103,103,199,199,199,199,199,199,199,199,199,199,199,118,118,118,118,118,118,118,118,118,118,117,117,117,117,117,117,117,117,117,119,119,119,119,119,119,119,119,119,119,120,120,120,120,120,120,120,120,120,120,121,121,121,121,121,121,121,121,121,121,122,122,122,122,122,122,122,122,122,122,127,127,127,127,127,127,127,127,127,127,124,124,124,124,124,124,124,124,124,124,125,125,125,125,125,125,125,125,125,125,126,126,126,126,126,126,126,126,126,126,123,123,123,123,123,123,123,123,123,123,131,131,131,131,131,131,131,131,131,131,129,129,129,129,129,129,129,129,129,129,128,128,128,128,128,128,128,128,128,128,130,130,130,130,130,130,130,130,130,130,132,132,132,132,132,132,132,132,132,132,200,200,200,200,200,200,200,200,201,201,201,201,201,201,201,201,202,202,202,202,202,202,202,202,203,203,203,203,203,203,203,203,204,204,204,204,204,204,204,204,133,133,133,133,133,133,133,133,133,133,205,205,205,205,205,205,205,205,206,206,206,206,206,206,206,206,207,207,207,207,207,207,207,207,134,134,134,134,134,134,134,134,134,134,135,135,135,135,135,135,135,135,135,135,208,208,208,208,208,208,208,208,209,209,209,209,209,209,209,209,136,136,136,136,136,136,136,136,136,136,210,210,210,210,210,210,210,210,211,211,211,211,211,211,211,211,212,212,212,212,212,212,212,212,137,137,137,137,137,137,137,137,137,137,213,213,213,213,213,213,213,213,138,138,138,138,138,138,138,138,138,138,214,214,214,214,214,214,214,214,215,215,215,215,215,215,215,215,216,216,216,216,216,216,216,216,217,217,217,217,217,217,217,217,139,139,139,139,139,139,139,139,139,139,140,140,140,140,140,140,140,140,140,140,218,218,218,218,218,218,218,218,219,219,219,219,219,219,219,219,220,220,220,220,220,220,220,220,221,221,221,221,221,221,221,221,222,222,222,222,222,222,222,222,223,223,223,223,223,223,223,223,224,224,224,224,224,224,224,224,225,225,225,225,225,225,225,225,226,226,226,226,226,226,226,226,141,141,141,141,141,141,141,141,141,141,227,227,227,227,227,227,227,227,228,228,228,228,228,228,228,228,229,229,229,229,229,229,229,229,143,143,143,143,143,143,143,143,143,143,142,142,142,142,142,142,142,142,142,142,147,147,147,147,147,147,147,147,147,147,146,146,146,146,146,146,146,146,146,146,154,154,154,154,154,154,154,154,154,154,148,148,148,148,148,148,148,148,148,148,145,145,145,145,145,145,145,145,145,145,230,230,230,230,230,230,230,230,230,230,231,231,231,231,231,231,231,231,231,231,232,232,232,232,232,232,232,232,232,232,144,144,144,144,144,144,144,144,144,144,155,155,155,155,155,155,155,155,155,155,152,152,152,152,152,152,152,152,152,152,153,153,153,153,153,153,153,153,153,153,156,156,156,156,156,156,156,156,156,156,157,157,157,157,157,157,157,157,157,157,151,151,151,151,151,151,151,151,151,151,150,150,150,150,150,150,150,150,150,150,149,149,149,149,149,149,149,149,149,149,158,158,158,158,158,158,158,158,158,158,158,159,159,159,159,159,159,159,159,159,159,233,233,233,233,233,233,233,233,233,233,234,234,234,234,234,234,234,234,234,234,235,235,235,235,235,235,235,235,235,235,236,236,236,236,236,236,236,236,236,236,237,237,237,237,237,237,237,237,237,237,237,238,238,238,238,238,238,238,238,238,238,238,160,160,160,160,160,160,160,160,160,160,161,161,161,161,161,161,161,162,162,162,162,162,162,162,162,162,162,163,163,163,163,163,163,163,163,163,168,168,168,168,168,168,168,168,168,168,164,164,164,164,164,164,164,164,164,166,166,166,166,166,166,166,166,166,165,165,165,165,165,165,165,165,165,167,167,167,167,167,167,167,167,167,169,169,169,169,169,169,169,169,169,169,170,170,170,170,170,170,170,170,170,170,174,174,174,174,174,174,174,174,174,174,175,175,175,175,175,175,175,175,175,175,176,176,176,176,176,176,176,176,176,176,177,177,177,177,177,177,177,177,177,177,178,178,178,178,178,178,178,178,178,178,179,179,179,179,179,179,179,179,179,179,180,180,180,180,180,180,180,180,180,180,181,181,181,181,181,181,181,181,181,181,182,182,182,182,182,182,182,182,182,182,183,183,183,183,183,183,183,183,183,183,184,184,184,184,184,184,184,184,184,184,185,185,185,185,185,185,185,185,185,185,186,186,186,186,186,186,186,186,186,186,187,187,187,187,187,187,187,187,187,187,188,188,188,188,188,188,188,188,188,188,171,171,171,171,171,171,171,171,171,171,172,172,172,172,172,172,172,172,172,172,189,189,189,189,189,189,189,189,189,189,173,173,173,173,173,173,173,173,173,173,195,195,195,195,195,195,195,195,195,195,197,197,197,197,197,197,197,197,197,197,196,196,196,196,196,196,196,196,196,196,193,193,193,193,193,193,193,193,193,193,190,190,190,190,190,190,190,190,190,190,191,191,191,191,191,191,191,191,191,191,192,192,192,192,192,192,192,192,192,192,194,194,194,194,194,194,194,194,194,194,198,198,198,198,198,198,198,198,198,104,104,104,104,104,104,104,105,105,105,105,105,105,105,105,105,107,107,107,107,107,107,107,107,107,107,239,239,239,239,239,239,239,239,239,239,240,240,240,240,240,240,240,240,241,241,241,241,241,241,241,241,241,241,242,242,242,242,242,242,242,242,242,242,243,243,243,243,243,243,243,243,243,243,244,244,244,244,244,244,244,244,108,108,108,108,108,108,108,108,108,108,245,245,245,245,245,245,245,116,116,116,116,116,116,116,116,116,116,114,114,114,114,114,114,114,114,113,113,113,113,113,113,113,113,113,246,246,246,246,246,246,246,199,199,199,199,199,199,199,199,199,199,199,158,158,159,159,233,233,234,234,235,235,236,236,237,237,238,238,160,160,1,1,102,102,100,100,101,101,103,103,2,2,3,3,4,4,5,5,6,6,7,7,8,8,9,9,10,10,11,11,12,12,13,13,14,14,15,15,16,16,17,17,18,18,19,19,20,20,21,21,22,22,23,23,24,24,25,25,26,26,27,27,28,28,29,29,30,30,31,31,32,32,33,33,34,34,35,35,36,36,37,37,38,38,39,39,40,40,41,41,42,42,43,43,44,44,45,45,46,46,47,47,48,48,49,49,50,50,51,51,52,52,53,53,54,54,55,55,56,56,57,57,58,58,59,59,60,60,61,61,62,62,63,63,64,64,65,65,66,66,67,67,68,68,69,69,70,70,71,71,72,72,73,73,74,74,75,75,76,76,77,77,78,78,79,79,80,80,81,81,82,82,83,83,84,84,85,85,86,86,87,87,88,88,89,89,90,90,91,91,92,92,93,93,94,94,95,95,96,96,97,97,98,98,99,99,199,199,199,199,114,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24,25,26,27,28,29,30,31,32,33,34,35,36,37,38,39,40,41,42,43,44,45,46,47,48,49,50,51,52,53,54,55,56,57,58,59,60,61,62,63,64,65,66,67,68,69,70,71,72,73,74,75,76,77,78,79,80,81,82,83,84,85,86,87,88,89,90,91,92,93,94,95,96,97,98,99,199,119,120,121,122,127,125,126,131,132,138,140,143,142,147,146,148,144,154,155,152,153,145,156,157,158,159,233,234,235,236,237,238,160,162,168,169,170,174,186,175,184,185,176,181,179,188,180,183,173,187,178,177,182,172,171,195,193,190,194,197,191,246,114,199,199,199,199,199,199,119,119,119,122,122,124,124,131,131,131,132,132,132,132,132,132,132,132,132,132,132,132,132,132,132,132,132,132,132,132,132,132,132,132,132,132,132,132,132,132,132,132,132,132,132,132,132,132,132,143,143,143,142,146,146,146,154,155,155,157,157,157,159,159,159,159,159,159,159,237,238,164,164,164,174,174,174,174,174,174,174,174,174,174,174,174,174,174,195,197,116,239,240,241,242,243,244,239,240,241,242,243,244,107,107,116,124,107,116,239,239,240,240,241,241,242,242,243,243,244,244,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24,25,26,27,28,29,30,31,32,33,34,35,36,37,38,39,40,41,42,43,44,45,46,47,48,49,50,51,52,53,54,55,56,57,58,59,60,61,62,63,64,65,66,67,68,69,70,71,72,73,74,75,76,77,78,79,80,81,82,83,84,85,86,87,88,89,90,91,92,93,94,95,96,97,98,99,100,101,102,103,230,231,232,158,233,234,235,236,237,238,105,107,239,241,242,243,108,171,190,117,118,172,169,191,144,145,192,164,165,166,167,168,132,133,134,135,136,137,138,139,140,141,123,124,125,126,193,146,147,142,148,159,160,162,163,143,119,120,121,122,194,195,196,197,149,150,151,198,173,152,153,174,175,176,177,178,179,180,181,154,155,182,183,184,185,186,187,188,170,189,127,128,129,130,131,156,157,113,116,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24,25,26,27,28,29,30,31,32,33,34,35,36,37,38,39,40,41,42,43,44,45,46,47,48,49,50,51,52,53,54,55,56,57,58,59,60,61,62,63,64,65,66,67,68,69,70,71,72,73,74,75,76,77,78,79,80,81,82,83,84,85,86,87,88,89,90,91,92,93,94,95,96,97,98,99,100,101,102,103,147,144,196,107,158,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24,25,26,27,28,29,30,31,32,33,34,35,36,37,38,39,40,41,42,43,44,45,46,47,48,49,50,51,52,53,54,55,56,57,58,59,60,61,62,63,64,65,66,67,68,69,70,71,72,73,74,75,76,77,78,79,80,81,82,83,84,85,86,87,88,89,90,91,92,93,94,95,96,97,98,99,100,101,102,103,143,142,230,231,232,158,233,234,235,236,237,238,105,107,171,190,117,118,172,169,191,144,145,192,164,165,166,167,168,132,133,134,135,136,137,138,139,140,141,123,124,125,126,193,146,147,148,159,160,162,163,119,120,121,122,194,195,196,197,149,150,151,198,173,152,153,174,175,176,177,178,179,180,181,154,155,182,183,184,185,186,187,188,170,189,127,128,129,130,131,156,157,158,1,54,56,59,60,61,63,65,66,68,69,73,76,78,81,84,85,88,91,96,97,99,113,1,54,56,59,60,61,63,65,66,68,69,73,76,78,81,84,85,88,91,96,97,99,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24,25,26,27,28,29,30,31,32,33,34,35,36,37,38,39,40,41,42,43,44,45,46,47,48,49,50,51,52,53,54,55,56,57,58,59,60,61,62,63,64,65,66,67,68,69,70,71,72,73,74,75,76,77,78,79,80,81,82,83,84,85,86,87,88,89,90,91,92,93,94,95,96,97,98,99,100,101,102,103,230,231,232,233,234,235,236,237,238,160,107,171,190,117,118,172,169,191,144,145,192,164,165,166,167,168,132,133,134,135,136,137,138,139,140,141,123,124,125,126,193,146,147,142,158,148,159,162,163,143,119,120,121,122,194,195,196,197,149,150,151,198,173,152,153,174,175,176,177,178,179,180,181,154,155,182,183,184,185,186,187,188,170,189,127,128,129,130,131,156,157,114,116,158,237,238,114,116,107,107,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24,25,26,27,28,29,30,31,32,33,34,35,36,37,38,39,40,41,42,43,44,45,46,47,48,49,50,51,52,53,54,55,56,57,58,59,60,61,62,63,64,65,66,67,68,69,70,71,72,73,74,75,76,77,78,79,80,81,82,83,84,85,86,87,88,89,90,91,92,93,94,95,96,97,98,99,100,101,102,103,143,142,230,231,232,158,233,234,235,236,237,238,107,171,190,117,118,172,169,191,144,145,192,164,165,166,167,168,132,133,134,135,136,137,138,139,140,141,123,124,125,126,193,146,147,148,159,160,162,163,119,120,121,122,194,195,196,197,149,150,151,198,173,152,153,174,175,176,177,178,179,180,181,154,155,182,183,184,185,186,187,188,170,189,127,128,129,130,131,156,157,107,107,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24,25,26,27,28,29,30,31,32,33,34,35,36,37,38,39,40,41,42,43,44,45,46,47,48,49,50,51,52,53,54,55,56,57,58,59,60,61,62,63,64,65,66,67,68,69,70,71,72,73,74,75,76,77,78,79,80,81,82,83,84,85,86,87,88,89,90,91,92,93,94,95,96,97,98,99,119,122,118,120,121,124,131,127,125,126,123,129,128,130,132,200,201,202,203,204,205,206,207,208,209,210,211,212,213,214,215,216,217,218,219,220,221,222,223,224,225,226,227,228,229,134,133,141,138,135,136,143,142,137,140,139,146,155,157,147,230,231,232,144,148,154,152,153,145,156,151,150,149,158,159,233,234,235,236,237,238,160,162,168,169,170,174,186,175,184,185,176,181,188,183,187,178,177,182,179,180,173,172,189,171,195,197,196,193,190,191,192,194,107,108,143,143,142,142,199,199,199,118,118,118,118,118,119,123,123,124,124,124,124,147,147,147,147,147,147,147,147,231,148,158,158,158,159,159,159,159,233,233,233,233,233,233,233,234,234,234,234,234,235,235,235,235,235,236,236,236,236,236,237,237,237,237,237,237,238,238,238,238,238,238,160,160,160,160,162,162,174,173,187,195,195,195,196,110,110,110,110,110,110,110,110,110,110,110,110,110,110,110,110,110,110,110,110,110,110,110,110,110,110,110,110,110,110,110,110,110,110,110,110,110,110,110,110,110,110,110,110,110,110,110,110,110,110,110,110,110,110,110,110,110,110,110,110,110,110,110,110,110,110,110,110,110,110,110,110,110,110,110,110,110,110,110,110,110,110,110,110,110,110,110,110,110,245,245],"f":[null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,[[["tokenstream",3]]],null,null,[[["tokenstream",3]]],null,null,[[["tokenstream",3]]],null,null,[[["tokenstream",3]]],null,null,[[["tokenstream",3]],["tokenbuffer",3]],[[["tokenstream",3]],["tokenbuffer",3]],[[],["cursor",3]],null,[[]],[[],["bool",15]],[[["delimiter",4]],["option",4]],[[],["option",4]],[[],["option",4]],[[],["option",4]],[[],["option",4]],[[],["tokenstream",3]],[[],["option",4]],[[],["span",3]],null,null,[[["parsestream",6]],["result",6]],null,[[],["ident",3]],null,null,[[]],[[],["bool",15]],[[],["usize",15]],[[],["option",4]],[[],["option",4]],[[],["option",4]],[[],["option",4]],[[],["iter",3]],[[],["itermut",3]],[[],["pairs",3]],[[],["pairsmut",3]],[[],["intopairs",3]],[[]],[[]],[[],[["pair",4],["option",4]]],[[],["bool",15]],[[],["bool",15]],[[]],[[["usize",15]]],[[]],[[["parsestream",6]],["result",6]],[[["parsestream",6]],["result",6]],[[["parsestream",6]],["result",6]],[[["parsestream",6]],["result",6]],null,null,null,null,null,null,null,null,null,[[]],[[]],[[]],[[],["option",4]],[[["option",4]]],[[]],null,null,[[],["span",3]],null,null,[[["abi",3]]],[[["anglebracketedgenericarguments",3]]],[[["attrstyle",4]]],[[["attribute",3]]],[[["barefnarg",3]]],[[["binop",4]]],[[["binding",3]]],[[["boundlifetimes",3]]],[[["constparam",3]]],[[["constraint",3]]],[[["data",4]]],[[["dataenum",3]]],[[["datastruct",3]]],[[["dataunion",3]]],[[["deriveinput",3]]],[[["expr",4]]],[[["exprbinary",3]]],[[["exprcall",3]]],[[["exprcast",3]]],[[["exprfield",3]]],[[["exprindex",3]]],[[["exprlit",3]]],[[["exprparen",3]]],[[["exprpath",3]]],[[["exprunary",3]]],[[["field",3]]],[[["fields",4]]],[[["fieldsnamed",3]]],[[["fieldsunnamed",3]]],[[["genericargument",4]]],[[["genericparam",4]]],[[["generics",3]]],[[["ident",3]]],[[["index",3]]],[[["lifetime",3]]],[[["lifetimedef",3]]],[[["lit",4]]],[[["litbool",3]]],[[["litbyte",3]]],[[["litbytestr",3]]],[[["litchar",3]]],[[["litfloat",3]]],[[["litint",3]]],[[["litstr",3]]],[[["macro",3]]],[[["macrodelimiter",4]]],[[["member",4]]],[[["meta",4]]],[[["metalist",3]]],[[["metanamevalue",3]]],[[["nestedmeta",4]]],[[["parenthesizedgenericarguments",3]]],[[["path",3]]],[[["patharguments",4]]],[[["pathsegment",3]]],[[["predicateeq",3]]],[[["predicatelifetime",3]]],[[["predicatetype",3]]],[[["qself",3]]],[[["returntype",4]]],[[["span",3]]],[[["traitbound",3]]],[[["traitboundmodifier",4]]],[[["type",4]]],[[["typearray",3]]],[[["typebarefn",3]]],[[["typegroup",3]]],[[["typeimpltrait",3]]],[[["typeinfer",3]]],[[["typemacro",3]]],[[["typenever",3]]],[[["typeparam",3]]],[[["typeparambound",4]]],[[["typeparen",3]]],[[["typepath",3]]],[[["typeptr",3]]],[[["typereference",3]]],[[["typeslice",3]]],[[["typetraitobject",3]]],[[["typetuple",3]]],[[["unop",4]]],[[["variadic",3]]],[[["variant",3]]],[[["viscrate",3]]],[[["vispublic",3]]],[[["visrestricted",3]]],[[["visibility",4]]],[[["whereclause",3]]],[[["wherepredicate",4]]],[[["abi",3]]],[[["anglebracketedgenericarguments",3]]],[[["attrstyle",4]]],[[["attribute",3]]],[[["barefnarg",3]]],[[["binop",4]]],[[["binding",3]]],[[["boundlifetimes",3]]],[[["constparam",3]]],[[["constraint",3]]],[[["data",4]]],[[["dataenum",3]]],[[["datastruct",3]]],[[["dataunion",3]]],[[["deriveinput",3]]],[[["expr",4]]],[[["exprbinary",3]]],[[["exprcall",3]]],[[["exprcast",3]]],[[["exprfield",3]]],[[["exprindex",3]]],[[["exprlit",3]]],[[["exprparen",3]]],[[["exprpath",3]]],[[["exprunary",3]]],[[["field",3]]],[[["fields",4]]],[[["fieldsnamed",3]]],[[["fieldsunnamed",3]]],[[["genericargument",4]]],[[["genericparam",4]]],[[["generics",3]]],[[["ident",3]]],[[["index",3]]],[[["lifetime",3]]],[[["lifetimedef",3]]],[[["lit",4]]],[[["litbool",3]]],[[["litbyte",3]]],[[["litbytestr",3]]],[[["litchar",3]]],[[["litfloat",3]]],[[["litint",3]]],[[["litstr",3]]],[[["macro",3]]],[[["macrodelimiter",4]]],[[["member",4]]],[[["meta",4]]],[[["metalist",3]]],[[["metanamevalue",3]]],[[["nestedmeta",4]]],[[["parenthesizedgenericarguments",3]]],[[["path",3]]],[[["patharguments",4]]],[[["pathsegment",3]]],[[["predicateeq",3]]],[[["predicatelifetime",3]]],[[["predicatetype",3]]],[[["qself",3]]],[[["returntype",4]]],[[["span",3]]],[[["traitbound",3]]],[[["traitboundmodifier",4]]],[[["type",4]]],[[["typearray",3]]],[[["typebarefn",3]]],[[["typegroup",3]]],[[["typeimpltrait",3]]],[[["typeinfer",3]]],[[["typemacro",3]]],[[["typenever",3]]],[[["typeparam",3]]],[[["typeparambound",4]]],[[["typeparen",3]]],[[["typepath",3]]],[[["typeptr",3]]],[[["typereference",3]]],[[["typeslice",3]]],[[["typetraitobject",3]]],[[["typetuple",3]]],[[["unop",4]]],[[["variadic",3]]],[[["variant",3]]],[[["viscrate",3]]],[[["vispublic",3]]],[[["visrestricted",3]]],[[["visibility",4]]],[[["whereclause",3]]],[[["wherepredicate",4]]],null,null,null,[[]],null,null,null,null,null,[[["parsestream",6]],["result",6]],null,null,null,[[["display",8]],["error",3]],[[],[["result",6],["parse",8]]],[[],["result",6]],[[["peek",8]],["bool",15]],[[["peek",8]],["bool",15]],[[["peek",8]],["bool",15]],[[],[["result",6],["punctuated",3]]],[[],["bool",15]],[[],["lookahead1",3]],[[]],[[["display",8]],["error",3]],[[],["result",6]],[[],["span",3]],[[],["cursor",3]],null,null,[[["tokenstream",3]],["result",6]],[[["tokenstream",3]],["result",6]],[[["str",15]],["result",6]],null,[[["span",3],["display",8]]],[[["totokens",8],["display",8]]],[[],["span",3]],[[],["tokenstream",3]],[[],["tokenstream",3]],[[["error",3]]],null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,[[["tokenstream",3]],[["result",6],["parse",8]]],[[["tokenstream",3]],[["result",6],["parse",8]]],[[["str",15]],[["result",6],["parse",8]]],null,null,null,null,null,null,null,null,[[],["span",3]],[[]],[[]],[[]],[[]],[[]],[[]],[[],["result",4]],[[],["result",4]],[[],["typeid",3]],[[],["span",3]],[[]],[[]],[[]],[[]],[[]],[[]],[[],["result",4]],[[],["result",4]],[[],["typeid",3]],[[],["span",3]],[[]],[[]],[[]],[[]],[[]],[[]],[[],["result",4]],[[],["result",4]],[[],["typeid",3]],[[],["span",3]],[[]],[[]],[[]],[[]],[[]],[[]],[[],["result",4]],[[],["result",4]],[[],["typeid",3]],[[],["span",3]],[[]],[[]],[[]],[[]],[[]],[[]],[[],["result",4]],[[],["result",4]],[[],["typeid",3]],[[],["span",3]],[[]],[[]],[[]],[[]],[[]],[[]],[[],["result",4]],[[],["result",4]],[[],["typeid",3]],[[],["span",3]],[[]],[[]],[[]],[[]],[[]],[[]],[[],["result",4]],[[],["result",4]],[[],["typeid",3]],[[],["span",3]],[[]],[[]],[[]],[[]],[[]],[[]],[[],["result",4]],[[],["result",4]],[[],["typeid",3]],[[],["span",3]],[[]],[[]],[[]],[[]],[[]],[[]],[[],["result",4]],[[],["result",4]],[[],["typeid",3]],[[],["span",3]],[[]],[[]],[[]],[[]],[[]],[[]],[[],["result",4]],[[],["result",4]],[[],["typeid",3]],[[],["span",3]],[[]],[[]],[[]],[[]],[[]],[[]],[[],["result",4]],[[],["result",4]],[[],["typeid",3]],[[],["span",3]],[[]],[[]],[[]],[[]],[[]],[[]],[[],["result",4]],[[],["result",4]],[[],["typeid",3]],[[],["span",3]],[[]],[[]],[[]],[[]],[[]],[[]],[[],["result",4]],[[],["result",4]],[[],["typeid",3]],[[],["span",3]],[[]],[[]],[[]],[[]],[[]],[[]],[[],["result",4]],[[],["result",4]],[[],["typeid",3]],[[],["span",3]],[[]],[[]],[[]],[[]],[[]],[[]],[[],["result",4]],[[],["result",4]],[[],["typeid",3]],[[],["span",3]],[[]],[[]],[[]],[[]],[[]],[[]],[[],["result",4]],[[],["result",4]],[[],["typeid",3]],[[],["span",3]],[[]],[[]],[[]],[[]],[[]],[[]],[[],["result",4]],[[],["result",4]],[[],["typeid",3]],[[],["span",3]],[[]],[[]],[[]],[[]],[[]],[[]],[[],["result",4]],[[],["result",4]],[[],["typeid",3]],[[],["span",3]],[[]],[[]],[[]],[[]],[[]],[[]],[[],["result",4]],[[],["result",4]],[[],["typeid",3]],[[],["span",3]],[[]],[[]],[[]],[[]],[[]],[[]],[[],["result",4]],[[],["result",4]],[[],["typeid",3]],[[],["span",3]],[[]],[[]],[[]],[[]],[[]],[[]],[[],["result",4]],[[],["result",4]],[[],["typeid",3]],[[],["span",3]],[[]],[[]],[[]],[[]],[[]],[[]],[[],["result",4]],[[],["result",4]],[[],["typeid",3]],[[],["span",3]],[[]],[[]],[[]],[[]],[[]],[[]],[[],["result",4]],[[],["result",4]],[[],["typeid",3]],[[],["span",3]],[[]],[[]],[[]],[[]],[[]],[[]],[[],["result",4]],[[],["result",4]],[[],["typeid",3]],[[],["span",3]],[[]],[[]],[[]],[[]],[[]],[[]],[[],["result",4]],[[],["result",4]],[[],["typeid",3]],[[],["span",3]],[[]],[[]],[[]],[[]],[[]],[[]],[[],["result",4]],[[],["result",4]],[[],["typeid",3]],[[],["span",3]],[[]],[[]],[[]],[[]],[[]],[[]],[[],["result",4]],[[],["result",4]],[[],["typeid",3]],[[],["span",3]],[[]],[[]],[[]],[[]],[[]],[[]],[[],["result",4]],[[],["result",4]],[[],["typeid",3]],[[],["span",3]],[[]],[[]],[[]],[[]],[[]],[[]],[[],["result",4]],[[],["result",4]],[[],["typeid",3]],[[],["span",3]],[[]],[[]],[[]],[[]],[[]],[[]],[[],["result",4]],[[],["result",4]],[[],["typeid",3]],[[],["span",3]],[[]],[[]],[[]],[[]],[[]],[[]],[[],["result",4]],[[],["result",4]],[[],["typeid",3]],[[],["span",3]],[[]],[[]],[[]],[[]],[[]],[[]],[[],["result",4]],[[],["result",4]],[[],["typeid",3]],[[],["span",3]],[[]],[[]],[[]],[[]],[[]],[[]],[[],["result",4]],[[],["result",4]],[[],["typeid",3]],[[],["span",3]],[[]],[[]],[[]],[[]],[[]],[[]],[[],["result",4]],[[],["result",4]],[[],["typeid",3]],[[],["span",3]],[[]],[[]],[[]],[[]],[[]],[[]],[[],["result",4]],[[],["result",4]],[[],["typeid",3]],[[],["span",3]],[[]],[[]],[[]],[[]],[[]],[[]],[[],["result",4]],[[],["result",4]],[[],["typeid",3]],[[],["span",3]],[[]],[[]],[[]],[[]],[[]],[[]],[[],["result",4]],[[],["result",4]],[[],["typeid",3]],[[],["span",3]],[[]],[[]],[[]],[[]],[[]],[[]],[[],["result",4]],[[],["result",4]],[[],["typeid",3]],[[],["span",3]],[[]],[[]],[[]],[[]],[[]],[[]],[[],["result",4]],[[],["result",4]],[[],["typeid",3]],[[],["span",3]],[[]],[[]],[[]],[[]],[[]],[[]],[[],["result",4]],[[],["result",4]],[[],["typeid",3]],[[],["span",3]],[[]],[[]],[[]],[[]],[[]],[[]],[[],["result",4]],[[],["result",4]],[[],["typeid",3]],[[],["span",3]],[[]],[[]],[[]],[[]],[[]],[[]],[[],["result",4]],[[],["result",4]],[[],["typeid",3]],[[],["span",3]],[[]],[[]],[[]],[[]],[[]],[[]],[[],["result",4]],[[],["result",4]],[[],["typeid",3]],[[],["span",3]],[[]],[[]],[[]],[[]],[[]],[[]],[[],["result",4]],[[],["result",4]],[[],["typeid",3]],[[],["span",3]],[[]],[[]],[[]],[[]],[[]],[[]],[[],["result",4]],[[],["result",4]],[[],["typeid",3]],[[],["span",3]],[[]],[[]],[[]],[[]],[[]],[[]],[[],["result",4]],[[],["result",4]],[[],["typeid",3]],[[],["span",3]],[[]],[[]],[[]],[[]],[[]],[[]],[[],["result",4]],[[],["result",4]],[[],["typeid",3]],[[],["span",3]],[[]],[[]],[[]],[[]],[[]],[[]],[[],["result",4]],[[],["result",4]],[[],["typeid",3]],[[],["span",3]],[[]],[[]],[[]],[[]],[[]],[[]],[[],["result",4]],[[],["result",4]],[[],["typeid",3]],[[],["span",3]],[[]],[[]],[[]],[[]],[[]],[[]],[[],["result",4]],[[],["result",4]],[[],["typeid",3]],[[],["span",3]],[[]],[[]],[[]],[[]],[[]],[[]],[[],["result",4]],[[],["result",4]],[[],["typeid",3]],[[],["span",3]],[[]],[[]],[[]],[[]],[[]],[[]],[[],["result",4]],[[],["result",4]],[[],["typeid",3]],[[],["span",3]],[[]],[[]],[[]],[[]],[[]],[[]],[[],["result",4]],[[],["result",4]],[[],["typeid",3]],[[],["span",3]],[[]],[[]],[[]],[[]],[[]],[[]],[[],["result",4]],[[],["result",4]],[[],["typeid",3]],[[],["span",3]],[[]],[[]],[[]],[[]],[[]],[[]],[[],["result",4]],[[],["result",4]],[[],["typeid",3]],[[],["span",3]],[[]],[[]],[[]],[[]],[[]],[[]],[[],["result",4]],[[],["result",4]],[[],["typeid",3]],[[],["span",3]],[[]],[[]],[[]],[[]],[[]],[[]],[[],["result",4]],[[],["result",4]],[[],["typeid",3]],[[],["span",3]],[[]],[[]],[[]],[[]],[[]],[[]],[[],["result",4]],[[],["result",4]],[[],["typeid",3]],[[],["span",3]],[[]],[[]],[[]],[[]],[[]],[[]],[[],["result",4]],[[],["result",4]],[[],["typeid",3]],[[],["span",3]],[[]],[[]],[[]],[[]],[[]],[[]],[[],["result",4]],[[],["result",4]],[[],["typeid",3]],[[],["span",3]],[[]],[[]],[[]],[[]],[[]],[[]],[[],["result",4]],[[],["result",4]],[[],["typeid",3]],[[],["span",3]],[[]],[[]],[[]],[[]],[[]],[[]],[[],["result",4]],[[],["result",4]],[[],["typeid",3]],[[],["span",3]],[[]],[[]],[[]],[[]],[[]],[[]],[[],["result",4]],[[],["result",4]],[[],["typeid",3]],[[],["span",3]],[[]],[[]],[[]],[[]],[[]],[[]],[[],["result",4]],[[],["result",4]],[[],["typeid",3]],[[],["span",3]],[[]],[[]],[[]],[[]],[[]],[[]],[[],["result",4]],[[],["result",4]],[[],["typeid",3]],[[],["span",3]],[[]],[[]],[[]],[[]],[[]],[[]],[[],["result",4]],[[],["result",4]],[[],["typeid",3]],[[],["span",3]],[[]],[[]],[[]],[[]],[[]],[[]],[[],["result",4]],[[],["result",4]],[[],["typeid",3]],[[],["span",3]],[[]],[[]],[[]],[[]],[[]],[[]],[[],["result",4]],[[],["result",4]],[[],["typeid",3]],[[],["span",3]],[[]],[[]],[[]],[[]],[[]],[[]],[[],["result",4]],[[],["result",4]],[[],["typeid",3]],[[],["span",3]],[[]],[[]],[[]],[[]],[[]],[[]],[[],["result",4]],[[],["result",4]],[[],["typeid",3]],[[],["span",3]],[[]],[[]],[[]],[[]],[[]],[[]],[[],["result",4]],[[],["result",4]],[[],["typeid",3]],[[],["span",3]],[[]],[[]],[[]],[[]],[[]],[[]],[[],["result",4]],[[],["result",4]],[[],["typeid",3]],[[],["span",3]],[[]],[[]],[[]],[[]],[[]],[[]],[[],["result",4]],[[],["result",4]],[[],["typeid",3]],[[],["span",3]],[[]],[[]],[[]],[[]],[[]],[[]],[[],["result",4]],[[],["result",4]],[[],["typeid",3]],[[],["span",3]],[[]],[[]],[[]],[[]],[[]],[[]],[[],["result",4]],[[],["result",4]],[[],["typeid",3]],[[],["span",3]],[[]],[[]],[[]],[[]],[[]],[[]],[[],["result",4]],[[],["result",4]],[[],["typeid",3]],[[],["span",3]],[[]],[[]],[[]],[[]],[[]],[[]],[[],["result",4]],[[],["result",4]],[[],["typeid",3]],[[],["span",3]],[[]],[[]],[[]],[[]],[[]],[[]],[[],["result",4]],[[],["result",4]],[[],["typeid",3]],[[],["span",3]],[[]],[[]],[[]],[[]],[[]],[[]],[[],["result",4]],[[],["result",4]],[[],["typeid",3]],[[],["span",3]],[[]],[[]],[[]],[[]],[[]],[[]],[[],["result",4]],[[],["result",4]],[[],["typeid",3]],[[],["span",3]],[[]],[[]],[[]],[[]],[[]],[[]],[[],["result",4]],[[],["result",4]],[[],["typeid",3]],[[],["span",3]],[[]],[[]],[[]],[[]],[[]],[[]],[[],["result",4]],[[],["result",4]],[[],["typeid",3]],[[],["span",3]],[[]],[[]],[[]],[[]],[[]],[[]],[[],["result",4]],[[],["result",4]],[[],["typeid",3]],[[],["span",3]],[[]],[[]],[[]],[[]],[[]],[[]],[[],["result",4]],[[],["result",4]],[[],["typeid",3]],[[],["span",3]],[[]],[[]],[[]],[[]],[[]],[[]],[[],["result",4]],[[],["result",4]],[[],["typeid",3]],[[],["span",3]],[[]],[[]],[[]],[[]],[[]],[[]],[[],["result",4]],[[],["result",4]],[[],["typeid",3]],[[],["span",3]],[[]],[[]],[[]],[[]],[[]],[[]],[[],["result",4]],[[],["result",4]],[[],["typeid",3]],[[],["span",3]],[[]],[[]],[[]],[[]],[[]],[[]],[[],["result",4]],[[],["result",4]],[[],["typeid",3]],[[],["span",3]],[[]],[[]],[[]],[[]],[[]],[[]],[[],["result",4]],[[],["result",4]],[[],["typeid",3]],[[],["span",3]],[[]],[[]],[[]],[[]],[[]],[[]],[[],["result",4]],[[],["result",4]],[[],["typeid",3]],[[],["span",3]],[[]],[[]],[[]],[[]],[[]],[[]],[[],["result",4]],[[],["result",4]],[[],["typeid",3]],[[],["span",3]],[[]],[[]],[[]],[[]],[[]],[[]],[[],["result",4]],[[],["result",4]],[[],["typeid",3]],[[],["span",3]],[[]],[[]],[[]],[[]],[[]],[[]],[[],["result",4]],[[],["result",4]],[[],["typeid",3]],[[],["span",3]],[[]],[[]],[[]],[[]],[[]],[[]],[[],["result",4]],[[],["result",4]],[[],["typeid",3]],[[],["span",3]],[[]],[[]],[[]],[[]],[[]],[[]],[[],["result",4]],[[],["result",4]],[[],["typeid",3]],[[],["span",3]],[[]],[[]],[[]],[[]],[[]],[[]],[[],["result",4]],[[],["result",4]],[[],["typeid",3]],[[],["span",3]],[[]],[[]],[[]],[[]],[[]],[[]],[[],["result",4]],[[],["result",4]],[[],["typeid",3]],[[],["span",3]],[[]],[[]],[[]],[[]],[[]],[[]],[[],["result",4]],[[],["result",4]],[[],["typeid",3]],[[],["span",3]],[[]],[[]],[[]],[[]],[[]],[[]],[[],["result",4]],[[],["result",4]],[[],["typeid",3]],[[]],[[]],[[]],[[]],[[]],[[]],[[],["result",4]],[[],["result",4]],[[],["typeid",3]],[[]],[[]],[[]],[[]],[[]],[[]],[[],["result",4]],[[],["result",4]],[[],["typeid",3]],[[]],[[]],[[]],[[]],[[]],[[]],[[],["result",4]],[[],["result",4]],[[],["typeid",3]],[[]],[[]],[[]],[[]],[[]],[[]],[[],["result",4]],[[],["result",4]],[[],["typeid",3]],[[],["span",3]],[[]],[[]],[[]],[[]],[[],["string",3]],[[]],[[]],[[],["result",4]],[[],["result",4]],[[],["typeid",3]],[[],["span",3]],[[]],[[]],[[]],[[]],[[]],[[]],[[],["result",4]],[[],["result",4]],[[],["typeid",3]],[[]],[[]],[[]],[[]],[[]],[[]],[[],["result",4]],[[],["result",4]],[[],["typeid",3]],[[],["span",3]],[[]],[[]],[[]],[[]],[[]],[[]],[[],["result",4]],[[],["result",4]],[[],["typeid",3]],[[],["span",3]],[[]],[[]],[[]],[[]],[[]],[[]],[[],["result",4]],[[],["result",4]],[[],["typeid",3]],[[],["span",3]],[[]],[[]],[[]],[[]],[[]],[[]],[[],["result",4]],[[],["result",4]],[[],["typeid",3]],[[],["span",3]],[[]],[[]],[[]],[[]],[[]],[[]],[[],["result",4]],[[],["result",4]],[[],["typeid",3]],[[],["span",3]],[[]],[[]],[[]],[[]],[[]],[[]],[[],["result",4]],[[],["result",4]],[[],["typeid",3]],[[],["span",3]],[[]],[[]],[[]],[[]],[[]],[[]],[[],["result",4]],[[],["result",4]],[[],["typeid",3]],[[],["span",3]],[[]],[[]],[[]],[[]],[[]],[[]],[[],["result",4]],[[],["result",4]],[[],["typeid",3]],[[],["span",3]],[[]],[[]],[[]],[[]],[[]],[[]],[[],["result",4]],[[],["result",4]],[[],["typeid",3]],[[],["span",3]],[[]],[[]],[[]],[[]],[[]],[[]],[[],["result",4]],[[],["result",4]],[[],["typeid",3]],[[],["span",3]],[[]],[[]],[[]],[[]],[[]],[[]],[[],["result",4]],[[],["result",4]],[[],["typeid",3]],[[],["span",3]],[[]],[[]],[[]],[[]],[[]],[[]],[[],["result",4]],[[],["result",4]],[[],["typeid",3]],[[],["span",3]],[[]],[[]],[[]],[[]],[[]],[[]],[[],["result",4]],[[],["result",4]],[[],["typeid",3]],[[],["span",3]],[[]],[[]],[[]],[[]],[[]],[[]],[[],["result",4]],[[],["result",4]],[[],["typeid",3]],[[],["span",3]],[[]],[[]],[[]],[[]],[[]],[[]],[[],["result",4]],[[],["result",4]],[[],["typeid",3]],[[],["span",3]],[[]],[[]],[[]],[[]],[[],["result",4]],[[],["result",4]],[[],["typeid",3]],[[],["span",3]],[[]],[[]],[[]],[[]],[[],["result",4]],[[],["result",4]],[[],["typeid",3]],[[],["span",3]],[[]],[[]],[[]],[[]],[[],["result",4]],[[],["result",4]],[[],["typeid",3]],[[],["span",3]],[[]],[[]],[[]],[[]],[[],["result",4]],[[],["result",4]],[[],["typeid",3]],[[],["span",3]],[[]],[[]],[[]],[[]],[[],["result",4]],[[],["result",4]],[[],["typeid",3]],[[],["span",3]],[[]],[[]],[[]],[[]],[[]],[[]],[[],["result",4]],[[],["result",4]],[[],["typeid",3]],[[],["span",3]],[[]],[[]],[[]],[[]],[[],["result",4]],[[],["result",4]],[[],["typeid",3]],[[],["span",3]],[[]],[[]],[[]],[[]],[[],["result",4]],[[],["result",4]],[[],["typeid",3]],[[],["span",3]],[[]],[[]],[[]],[[]],[[],["result",4]],[[],["result",4]],[[],["typeid",3]],[[],["span",3]],[[]],[[]],[[]],[[]],[[]],[[]],[[],["result",4]],[[],["result",4]],[[],["typeid",3]],[[],["span",3]],[[]],[[]],[[]],[[]],[[]],[[]],[[],["result",4]],[[],["result",4]],[[],["typeid",3]],[[],["span",3]],[[]],[[]],[[]],[[]],[[],["result",4]],[[],["result",4]],[[],["typeid",3]],[[],["span",3]],[[]],[[]],[[]],[[]],[[],["result",4]],[[],["result",4]],[[],["typeid",3]],[[],["span",3]],[[]],[[]],[[]],[[]],[[]],[[]],[[],["result",4]],[[],["result",4]],[[],["typeid",3]],[[],["span",3]],[[]],[[]],[[]],[[]],[[],["result",4]],[[],["result",4]],[[],["typeid",3]],[[],["span",3]],[[]],[[]],[[]],[[]],[[],["result",4]],[[],["result",4]],[[],["typeid",3]],[[],["span",3]],[[]],[[]],[[]],[[]],[[],["result",4]],[[],["result",4]],[[],["typeid",3]],[[],["span",3]],[[]],[[]],[[]],[[]],[[]],[[]],[[],["result",4]],[[],["result",4]],[[],["typeid",3]],[[],["span",3]],[[]],[[]],[[]],[[]],[[],["result",4]],[[],["result",4]],[[],["typeid",3]],[[],["span",3]],[[]],[[]],[[]],[[]],[[]],[[]],[[],["result",4]],[[],["result",4]],[[],["typeid",3]],[[],["span",3]],[[]],[[]],[[]],[[]],[[],["result",4]],[[],["result",4]],[[],["typeid",3]],[[],["span",3]],[[]],[[]],[[]],[[]],[[],["result",4]],[[],["result",4]],[[],["typeid",3]],[[],["span",3]],[[]],[[]],[[]],[[]],[[],["result",4]],[[],["result",4]],[[],["typeid",3]],[[],["span",3]],[[]],[[]],[[]],[[]],[[],["result",4]],[[],["result",4]],[[],["typeid",3]],[[],["span",3]],[[]],[[]],[[]],[[]],[[]],[[]],[[],["result",4]],[[],["result",4]],[[],["typeid",3]],[[],["span",3]],[[]],[[]],[[]],[[]],[[]],[[]],[[],["result",4]],[[],["result",4]],[[],["typeid",3]],[[],["span",3]],[[]],[[]],[[]],[[]],[[],["result",4]],[[],["result",4]],[[],["typeid",3]],[[],["span",3]],[[]],[[]],[[]],[[]],[[],["result",4]],[[],["result",4]],[[],["typeid",3]],[[],["span",3]],[[]],[[]],[[]],[[]],[[],["result",4]],[[],["result",4]],[[],["typeid",3]],[[],["span",3]],[[]],[[]],[[]],[[]],[[],["result",4]],[[],["result",4]],[[],["typeid",3]],[[],["span",3]],[[]],[[]],[[]],[[]],[[],["result",4]],[[],["result",4]],[[],["typeid",3]],[[],["span",3]],[[]],[[]],[[]],[[]],[[],["result",4]],[[],["result",4]],[[],["typeid",3]],[[],["span",3]],[[]],[[]],[[]],[[]],[[],["result",4]],[[],["result",4]],[[],["typeid",3]],[[],["span",3]],[[]],[[]],[[]],[[]],[[],["result",4]],[[],["result",4]],[[],["typeid",3]],[[],["span",3]],[[]],[[]],[[]],[[]],[[],["result",4]],[[],["result",4]],[[],["typeid",3]],[[],["span",3]],[[]],[[]],[[]],[[]],[[]],[[]],[[],["result",4]],[[],["result",4]],[[],["typeid",3]],[[],["span",3]],[[]],[[]],[[]],[[]],[[],["result",4]],[[],["result",4]],[[],["typeid",3]],[[],["span",3]],[[]],[[]],[[]],[[]],[[],["result",4]],[[],["result",4]],[[],["typeid",3]],[[],["span",3]],[[]],[[]],[[]],[[]],[[],["result",4]],[[],["result",4]],[[],["typeid",3]],[[],["span",3]],[[]],[[]],[[]],[[]],[[]],[[]],[[],["result",4]],[[],["result",4]],[[],["typeid",3]],[[],["span",3]],[[]],[[]],[[]],[[]],[[]],[[]],[[],["result",4]],[[],["result",4]],[[],["typeid",3]],[[],["span",3]],[[]],[[]],[[]],[[]],[[]],[[]],[[],["result",4]],[[],["result",4]],[[],["typeid",3]],[[],["span",3]],[[]],[[]],[[]],[[]],[[]],[[]],[[],["result",4]],[[],["result",4]],[[],["typeid",3]],[[],["span",3]],[[]],[[]],[[]],[[]],[[]],[[]],[[],["result",4]],[[],["result",4]],[[],["typeid",3]],[[],["span",3]],[[]],[[]],[[]],[[]],[[]],[[]],[[],["result",4]],[[],["result",4]],[[],["typeid",3]],[[],["span",3]],[[]],[[]],[[]],[[]],[[]],[[]],[[],["result",4]],[[],["result",4]],[[],["typeid",3]],[[],["span",3]],[[]],[[]],[[]],[[]],[[]],[[]],[[],["result",4]],[[],["result",4]],[[],["typeid",3]],[[],["span",3]],[[]],[[]],[[]],[[]],[[]],[[]],[[],["result",4]],[[],["result",4]],[[],["typeid",3]],[[],["span",3]],[[]],[[]],[[]],[[]],[[]],[[]],[[],["result",4]],[[],["result",4]],[[],["typeid",3]],[[],["span",3]],[[]],[[]],[[]],[[]],[[]],[[]],[[],["result",4]],[[],["result",4]],[[],["typeid",3]],[[],["span",3]],[[]],[[]],[[]],[[]],[[]],[[]],[[],["result",4]],[[],["result",4]],[[],["typeid",3]],[[],["span",3]],[[]],[[]],[[]],[[]],[[]],[[]],[[],["result",4]],[[],["result",4]],[[],["typeid",3]],[[],["span",3]],[[]],[[]],[[]],[[]],[[]],[[]],[[],["result",4]],[[],["result",4]],[[],["typeid",3]],[[],["span",3]],[[]],[[]],[[]],[[]],[[]],[[]],[[],["result",4]],[[],["result",4]],[[],["typeid",3]],[[],["span",3]],[[]],[[]],[[]],[[]],[[]],[[]],[[],["result",4]],[[],["result",4]],[[],["typeid",3]],[[],["span",3]],[[]],[[]],[[]],[[]],[[]],[[]],[[],["result",4]],[[],["result",4]],[[],["typeid",3]],[[],["span",3]],[[]],[[]],[[]],[[]],[[]],[[]],[[],["result",4]],[[],["result",4]],[[],["typeid",3]],[[],["span",3]],[[]],[[]],[[]],[[]],[[]],[[]],[[],["result",4]],[[],["result",4]],[[],["typeid",3]],[[],["span",3]],[[]],[[]],[[]],[[]],[[],["string",3]],[[]],[[]],[[],["result",4]],[[],["result",4]],[[],["typeid",3]],[[],["span",3]],[[]],[[]],[[]],[[]],[[]],[[]],[[],["result",4]],[[],["result",4]],[[],["typeid",3]],[[],["span",3]],[[]],[[]],[[]],[[]],[[]],[[]],[[],["result",4]],[[],["result",4]],[[],["typeid",3]],[[],["span",3]],[[]],[[]],[[]],[[]],[[]],[[]],[[],["result",4]],[[],["result",4]],[[],["typeid",3]],[[],["span",3]],[[]],[[]],[[]],[[]],[[]],[[]],[[],["result",4]],[[],["result",4]],[[],["typeid",3]],[[],["span",3]],[[]],[[]],[[]],[[]],[[]],[[]],[[],["result",4]],[[],["result",4]],[[],["typeid",3]],[[],["span",3]],[[]],[[]],[[]],[[]],[[],["string",3]],[[]],[[]],[[],["result",4]],[[],["result",4]],[[],["typeid",3]],[[],["span",3]],[[]],[[]],[[]],[[]],[[],["string",3]],[[]],[[]],[[],["result",4]],[[],["result",4]],[[],["typeid",3]],[[],["span",3]],[[]],[[]],[[]],[[]],[[]],[[]],[[],["result",4]],[[],["result",4]],[[],["typeid",3]],[[]],[[]],[[]],[[]],[[],["result",4]],[[],["result",4]],[[],["typeid",3]],[[],["span",3]],[[]],[[]],[[]],[[]],[[]],[[]],[[],["result",4]],[[],["result",4]],[[],["typeid",3]],[[]],[[]],[[]],[[]],[[]],[[]],[[],["result",4]],[[],["result",4]],[[],["typeid",3]],[[],["span",3]],[[]],[[]],[[]],[[]],[[]],[[]],[[],["result",4]],[[],["result",4]],[[],["typeid",3]],[[]],[[]],[[]],[[]],[[]],[[]],[[],["result",4]],[[],["result",4]],[[],["typeid",3]],[[]],[[]],[[]],[[]],[[]],[[]],[[],["result",4]],[[],["result",4]],[[],["typeid",3]],[[]],[[]],[[]],[[]],[[]],[[]],[[],["result",4]],[[],["result",4]],[[],["typeid",3]],[[]],[[]],[[]],[[]],[[]],[[]],[[],["result",4]],[[],["result",4]],[[],["typeid",3]],[[],["span",3]],[[]],[[]],[[]],[[]],[[]],[[]],[[],["result",4]],[[],["result",4]],[[],["typeid",3]],[[],["span",3]],[[]],[[]],[[]],[[]],[[]],[[]],[[],["result",4]],[[],["result",4]],[[],["typeid",3]],[[],["span",3]],[[]],[[]],[[]],[[]],[[]],[[]],[[],["result",4]],[[],["result",4]],[[],["typeid",3]],[[],["span",3]],[[]],[[]],[[]],[[]],[[]],[[]],[[],["result",4]],[[],["result",4]],[[],["typeid",3]],[[],["span",3]],[[]],[[]],[[]],[[]],[[]],[[]],[[],["result",4]],[[],["result",4]],[[],["typeid",3]],[[],["span",3]],[[]],[[]],[[]],[[]],[[]],[[]],[[],["result",4]],[[],["result",4]],[[],["typeid",3]],[[],["span",3]],[[]],[[]],[[]],[[]],[[]],[[]],[[],["result",4]],[[],["result",4]],[[],["typeid",3]],[[],["span",3]],[[]],[[]],[[]],[[]],[[]],[[]],[[],["result",4]],[[],["result",4]],[[],["typeid",3]],[[],["span",3]],[[]],[[]],[[]],[[]],[[]],[[]],[[],["result",4]],[[],["result",4]],[[],["typeid",3]],[[],["span",3]],[[]],[[]],[[]],[[]],[[]],[[]],[[],["result",4]],[[],["result",4]],[[],["typeid",3]],[[],["span",3]],[[]],[[]],[[]],[[]],[[]],[[]],[[],["result",4]],[[],["result",4]],[[],["typeid",3]],[[],["span",3]],[[]],[[]],[[]],[[]],[[]],[[]],[[],["result",4]],[[],["result",4]],[[],["typeid",3]],[[],["span",3]],[[]],[[]],[[]],[[]],[[]],[[]],[[],["result",4]],[[],["result",4]],[[],["typeid",3]],[[],["span",3]],[[]],[[]],[[]],[[]],[[]],[[]],[[],["result",4]],[[],["result",4]],[[],["typeid",3]],[[],["span",3]],[[]],[[]],[[]],[[]],[[]],[[]],[[],["result",4]],[[],["result",4]],[[],["typeid",3]],[[],["span",3]],[[]],[[]],[[]],[[]],[[]],[[]],[[],["result",4]],[[],["result",4]],[[],["typeid",3]],[[],["span",3]],[[]],[[]],[[]],[[]],[[]],[[]],[[],["result",4]],[[],["result",4]],[[],["typeid",3]],[[],["span",3]],[[]],[[]],[[]],[[]],[[]],[[]],[[],["result",4]],[[],["result",4]],[[],["typeid",3]],[[],["span",3]],[[]],[[]],[[]],[[]],[[]],[[]],[[],["result",4]],[[],["result",4]],[[],["typeid",3]],[[],["span",3]],[[]],[[]],[[]],[[]],[[]],[[]],[[],["result",4]],[[],["result",4]],[[],["typeid",3]],[[],["span",3]],[[]],[[]],[[]],[[]],[[]],[[]],[[],["result",4]],[[],["result",4]],[[],["typeid",3]],[[],["span",3]],[[]],[[]],[[]],[[]],[[]],[[]],[[],["result",4]],[[],["result",4]],[[],["typeid",3]],[[],["span",3]],[[]],[[]],[[]],[[]],[[]],[[]],[[],["result",4]],[[],["result",4]],[[],["typeid",3]],[[],["span",3]],[[]],[[]],[[]],[[]],[[]],[[]],[[],["result",4]],[[],["result",4]],[[],["typeid",3]],[[],["span",3]],[[]],[[]],[[]],[[]],[[]],[[]],[[],["result",4]],[[],["result",4]],[[],["typeid",3]],[[],["span",3]],[[]],[[]],[[]],[[]],[[]],[[]],[[],["result",4]],[[],["result",4]],[[],["typeid",3]],[[],["span",3]],[[]],[[]],[[]],[[]],[[]],[[]],[[],["result",4]],[[],["result",4]],[[],["typeid",3]],[[],["span",3]],[[]],[[]],[[]],[[]],[[]],[[]],[[],["result",4]],[[],["result",4]],[[],["typeid",3]],[[],["span",3]],[[]],[[]],[[]],[[]],[[]],[[]],[[],["result",4]],[[],["result",4]],[[],["typeid",3]],[[]],[[]],[[]],[[]],[[]],[[]],[[],["result",4]],[[],["result",4]],[[],["typeid",3]],[[]],[[]],[[]],[[]],[[],["result",4]],[[],["result",4]],[[],["typeid",3]],[[]],[[]],[[]],[[]],[[]],[[]],[[],["result",4]],[[],["result",4]],[[],["typeid",3]],[[],["span",3]],[[]],[[]],[[]],[[]],[[]],[[]],[[],["result",4]],[[],["result",4]],[[],["typeid",3]],[[]],[[]],[[]],[[]],[[]],[[]],[[]],[[],["result",4]],[[],["result",4]],[[],["typeid",3]],[[]],[[]],[[]],[[]],[[]],[[],["result",4]],[[],["result",4]],[[],["typeid",3]],[[]],[[]],[[]],[[]],[[]],[[]],[[]],[[],["result",4]],[[],["result",4]],[[],["typeid",3]],[[]],[[]],[[]],[[]],[[]],[[]],[[]],[[],["result",4]],[[],["result",4]],[[],["typeid",3]],[[]],[[]],[[]],[[]],[[]],[[]],[[]],[[],["result",4]],[[],["result",4]],[[],["typeid",3]],[[]],[[]],[[]],[[]],[[]],[[],["result",4]],[[],["result",4]],[[],["typeid",3]],[[],["span",3]],[[]],[[]],[[]],[[]],[[]],[[]],[[],["result",4]],[[],["result",4]],[[],["typeid",3]],[[]],[[]],[[]],[[]],[[],["result",4]],[[],["result",4]],[[],["typeid",3]],[[]],[[]],[[]],[[]],[[],["string",3]],[[]],[[]],[[],["result",4]],[[],["result",4]],[[],["typeid",3]],[[]],[[]],[[],["string",3]],[[]],[[]],[[],["result",4]],[[],["result",4]],[[],["typeid",3]],[[]],[[]],[[]],[[]],[[]],[[]],[[],["result",4]],[[],["result",4]],[[],["typeid",3]],[[]],[[]],[[]],[[]],[[],["result",4]],[[],["result",4]],[[],["typeid",3]],[[["ident",3]],["bool",15]],[[],["bool",15]],[[]],[[["ident",3]],["ordering",4]],[[["formatter",3]],[["result",4],["error",3]]],[[],["ident",3]],[[["ident",3]],[["ordering",4],["option",4]]],[[["formatter",3]],[["result",4],["error",3]]],[[],[["option",4],["span",3]]],[[["formatter",3]],[["result",4],["error",3]]],[[["tokenstream",3]]],[[["cursor",3]],["bool",15]],[[],["str",15]],[[["cursor",3]],["bool",15]],[[],["str",15]],[[["cursor",3]],["bool",15]],[[],["str",15]],[[["cursor",3]],["bool",15]],[[],["str",15]],[[["cursor",3]],["bool",15]],[[],["str",15]],[[["cursor",3]],["bool",15]],[[],["str",15]],[[["cursor",3]],["bool",15]],[[],["str",15]],[[["cursor",3]],["bool",15]],[[],["str",15]],[[["cursor",3]],["bool",15]],[[],["str",15]],[[["cursor",3]],["bool",15]],[[],["str",15]],[[["cursor",3]],["bool",15]],[[],["str",15]],[[["cursor",3]],["bool",15]],[[],["str",15]],[[["cursor",3]],["bool",15]],[[],["str",15]],[[["cursor",3]],["bool",15]],[[],["str",15]],[[["cursor",3]],["bool",15]],[[],["str",15]],[[["cursor",3]],["bool",15]],[[],["str",15]],[[["cursor",3]],["bool",15]],[[],["str",15]],[[["cursor",3]],["bool",15]],[[],["str",15]],[[["cursor",3]],["bool",15]],[[],["str",15]],[[["cursor",3]],["bool",15]],[[],["str",15]],[[["cursor",3]],["bool",15]],[[],["str",15]],[[["cursor",3]],["bool",15]],[[],["str",15]],[[["cursor",3]],["bool",15]],[[],["str",15]],[[["cursor",3]],["bool",15]],[[],["str",15]],[[["cursor",3]],["bool",15]],[[],["str",15]],[[["cursor",3]],["bool",15]],[[],["str",15]],[[["cursor",3]],["bool",15]],[[],["str",15]],[[["cursor",3]],["bool",15]],[[],["str",15]],[[["cursor",3]],["bool",15]],[[],["str",15]],[[["cursor",3]],["bool",15]],[[],["str",15]],[[["cursor",3]],["bool",15]],[[],["str",15]],[[["cursor",3]],["bool",15]],[[],["str",15]],[[["cursor",3]],["bool",15]],[[],["str",15]],[[["cursor",3]],["bool",15]],[[],["str",15]],[[["cursor",3]],["bool",15]],[[],["str",15]],[[["cursor",3]],["bool",15]],[[],["str",15]],[[["cursor",3]],["bool",15]],[[],["str",15]],[[["cursor",3]],["bool",15]],[[],["str",15]],[[["cursor",3]],["bool",15]],[[],["str",15]],[[["cursor",3]],["bool",15]],[[],["str",15]],[[["cursor",3]],["bool",15]],[[],["str",15]],[[["cursor",3]],["bool",15]],[[],["str",15]],[[["cursor",3]],["bool",15]],[[],["str",15]],[[["cursor",3]],["bool",15]],[[],["str",15]],[[["cursor",3]],["bool",15]],[[],["str",15]],[[["cursor",3]],["bool",15]],[[],["str",15]],[[["cursor",3]],["bool",15]],[[],["str",15]],[[["cursor",3]],["bool",15]],[[],["str",15]],[[["cursor",3]],["bool",15]],[[],["str",15]],[[["cursor",3]],["bool",15]],[[],["str",15]],[[["cursor",3]],["bool",15]],[[],["str",15]],[[["cursor",3]],["bool",15]],[[],["str",15]],[[["cursor",3]],["bool",15]],[[],["str",15]],[[["cursor",3]],["bool",15]],[[],["str",15]],[[["cursor",3]],["bool",15]],[[],["str",15]],[[["cursor",3]],["bool",15]],[[],["str",15]],[[["cursor",3]],["bool",15]],[[],["str",15]],[[["cursor",3]],["bool",15]],[[],["str",15]],[[["cursor",3]],["bool",15]],[[],["str",15]],[[["cursor",3]],["bool",15]],[[],["str",15]],[[["cursor",3]],["bool",15]],[[],["str",15]],[[["cursor",3]],["bool",15]],[[],["str",15]],[[["cursor",3]],["bool",15]],[[],["str",15]],[[["cursor",3]],["bool",15]],[[],["str",15]],[[["cursor",3]],["bool",15]],[[],["str",15]],[[["cursor",3]],["bool",15]],[[],["str",15]],[[["cursor",3]],["bool",15]],[[],["str",15]],[[["cursor",3]],["bool",15]],[[],["str",15]],[[["cursor",3]],["bool",15]],[[],["str",15]],[[["cursor",3]],["bool",15]],[[],["str",15]],[[["cursor",3]],["bool",15]],[[],["str",15]],[[["cursor",3]],["bool",15]],[[],["str",15]],[[["cursor",3]],["bool",15]],[[],["str",15]],[[["cursor",3]],["bool",15]],[[],["str",15]],[[["cursor",3]],["bool",15]],[[],["str",15]],[[["cursor",3]],["bool",15]],[[],["str",15]],[[["cursor",3]],["bool",15]],[[],["str",15]],[[["cursor",3]],["bool",15]],[[],["str",15]],[[["cursor",3]],["bool",15]],[[],["str",15]],[[["cursor",3]],["bool",15]],[[],["str",15]],[[["cursor",3]],["bool",15]],[[],["str",15]],[[["cursor",3]],["bool",15]],[[],["str",15]],[[["cursor",3]],["bool",15]],[[],["str",15]],[[["cursor",3]],["bool",15]],[[],["str",15]],[[["cursor",3]],["bool",15]],[[],["str",15]],[[["cursor",3]],["bool",15]],[[],["str",15]],[[["cursor",3]],["bool",15]],[[],["str",15]],[[["cursor",3]],["bool",15]],[[],["str",15]],[[["cursor",3]],["bool",15]],[[],["str",15]],[[["cursor",3]],["bool",15]],[[],["str",15]],[[["cursor",3]],["bool",15]],[[],["str",15]],[[["cursor",3]],["bool",15]],[[],["str",15]],[[["cursor",3]],["bool",15]],[[],["str",15]],[[["cursor",3]],["bool",15]],[[],["str",15]],[[["cursor",3]],["bool",15]],[[],["str",15]],[[["cursor",3]],["bool",15]],[[],["str",15]],[[["cursor",3]],["bool",15]],[[],["str",15]],[[["cursor",3]],["bool",15]],[[],["str",15]],[[["cursor",3]],["bool",15]],[[],["str",15]],[[["cursor",3]],["bool",15]],[[],["str",15]],[[["cursor",3]],["bool",15]],[[],["str",15]],[[["cursor",3]],["bool",15]],[[],["str",15]],[[["cursor",3]],["bool",15]],[[],["str",15]],[[["cursor",3]],["bool",15]],[[],["str",15]],[[["cursor",3]],["bool",15]],[[],["str",15]],[[["cursor",3]],["bool",15]],[[],["str",15]],[[["cursor",3]],["bool",15]],[[],["str",15]],[[["cursor",3]],["bool",15]],[[],["str",15]],[[["cursor",3]],["bool",15]],[[],["str",15]],[[["cursor",3]],["bool",15]],[[],["str",15]],[[["cursor",3]],["bool",15]],[[],["str",15]],[[["cursor",3]],["bool",15]],[[],["str",15]],[[["cursor",3]],["bool",15]],[[],["str",15]],[[["parsestream",6]],["result",6]],[[],["ident",3]],[[]],[[["parsestream",6]],["result",6]],[[["parsestream",6]],["result",6]],[[["parsestream",6]],["result",6]],[[["parsestream",6]],["result",6]],[[["parsestream",6]],["result",6]],[[["parsestream",6]],["result",6]],[[["parsestream",6]],["result",6]],[[["parsestream",6]],["result",6]],[[["parsestream",6]],["result",6]],[[["parsestream",6]],["result",6]],[[["parsestream",6]],["result",6]],[[["parsestream",6]],["result",6]],[[["parsestream",6]],["result",6]],[[["parsestream",6]],["result",6]],[[["parsestream",6]],["result",6]],[[["parsestream",6]],["result",6]],[[["parsestream",6]],["result",6]],[[["parsestream",6]],["result",6]],[[["parsestream",6]],["result",6]],[[["parsestream",6]],["result",6]],[[["parsestream",6]],["result",6]],[[["parsestream",6]],["result",6]],[[["parsestream",6]],["result",6]],[[["parsestream",6]],["result",6]],[[["parsestream",6]],["result",6]],[[["parsestream",6]],["result",6]],[[["parsestream",6]],["result",6]],[[["parsestream",6]],["result",6]],[[["parsestream",6]],["result",6]],[[["parsestream",6]],["result",6]],[[["parsestream",6]],["result",6]],[[["parsestream",6]],["result",6]],[[["parsestream",6]],["result",6]],[[["parsestream",6]],["result",6]],[[["parsestream",6]],["result",6]],[[["parsestream",6]],["result",6]],[[["parsestream",6]],["result",6]],[[["parsestream",6]],["result",6]],[[["parsestream",6]],["result",6]],[[["parsestream",6]],["result",6]],[[["parsestream",6]],["result",6]],[[["parsestream",6]],["result",6]],[[["parsestream",6]],["result",6]],[[["parsestream",6]],["result",6]],[[["parsestream",6]],["result",6]],[[["parsestream",6]],["result",6]],[[["parsestream",6]],["result",6]],[[["parsestream",6]],["result",6]],[[["parsestream",6]],["result",6]],[[["parsestream",6]],["result",6]],[[["parsestream",6]],["result",6]],[[["parsestream",6]],["result",6]],[[["parsestream",6]],["result",6]],[[["parsestream",6]],["result",6]],[[["parsestream",6]],["result",6]],[[["parsestream",6]],["result",6]],[[["parsestream",6]],["result",6]],[[["parsestream",6]],["result",6]],[[["parsestream",6]],["result",6]],[[["parsestream",6]],["result",6]],[[["parsestream",6]],["result",6]],[[["parsestream",6]],["result",6]],[[["parsestream",6]],["result",6]],[[["parsestream",6]],["result",6]],[[["parsestream",6]],["result",6]],[[["parsestream",6]],["result",6]],[[["parsestream",6]],["result",6]],[[["parsestream",6]],["result",6]],[[["parsestream",6]],["result",6]],[[["parsestream",6]],["result",6]],[[["parsestream",6]],["result",6]],[[["parsestream",6]],["result",6]],[[["parsestream",6]],["result",6]],[[["parsestream",6]],["result",6]],[[["parsestream",6]],["result",6]],[[["parsestream",6]],["result",6]],[[["parsestream",6]],["result",6]],[[["parsestream",6]],["result",6]],[[["parsestream",6]],["result",6]],[[["parsestream",6]],["result",6]],[[["parsestream",6]],["result",6]],[[["parsestream",6]],["result",6]],[[["parsestream",6]],["result",6]],[[["parsestream",6]],["result",6]],[[["parsestream",6]],["result",6]],[[["parsestream",6]],["result",6]],[[["parsestream",6]],["result",6]],[[["parsestream",6]],["result",6]],[[["parsestream",6]],["result",6]],[[["parsestream",6]],["result",6]],[[["parsestream",6]],["result",6]],[[["parsestream",6]],["result",6]],[[["parsestream",6]],["result",6]],[[["parsestream",6]],["result",6]],[[["parsestream",6]],["result",6]],[[["parsestream",6]],["result",6]],[[["parsestream",6]],["result",6]],[[["parsestream",6]],["result",6]],[[["parsestream",6]],["result",6]],[[["parsestream",6]],["result",6]],[[["parsestream",6]],["result",6]],[[["parsestream",6]],["result",6]],[[["parsestream",6]],["result",6]],[[["parsestream",6]],["result",6]],[[["parsestream",6]],["result",6]],[[["parsestream",6]],["result",6]],[[["parsestream",6]],["result",6]],[[["parsestream",6]],["result",6]],[[["parsestream",6]],["result",6]],[[["parsestream",6]],["result",6]],[[["parsestream",6]],["result",6]],[[["parsestream",6]],["result",6]],[[["parsestream",6]],["result",6]],[[["parsestream",6]],["result",6]],[[["parsestream",6]],["result",6]],[[["parsestream",6]],["result",6]],[[["parsestream",6]],["result",6]],[[["parsestream",6]],["result",6]],[[["parsestream",6]],["result",6]],[[["parsestream",6]],["result",6]],[[["parsestream",6]],["result",6]],[[["parsestream",6]],["result",6]],[[["parsestream",6]],["result",6]],[[["parsestream",6]],["result",6]],[[["parsestream",6]],["result",6]],[[["parsestream",6]],["result",6]],[[["parsestream",6]],["result",6]],[[["parsestream",6]],["result",6]],[[["parsestream",6]],["result",6]],[[["parsestream",6]],["result",6]],[[["parsestream",6]],["result",6]],[[["parsestream",6]],["result",6]],[[["parsestream",6]],["result",6]],[[["parsestream",6]],["result",6]],[[["parsestream",6]],["result",6]],[[["parsestream",6]],["result",6]],[[["parsestream",6]],["result",6]],[[["parsestream",6]],["result",6]],[[["parsestream",6]],["result",6]],[[["parsestream",6]],["result",6]],[[["parsestream",6]],["result",6]],[[["parsestream",6]],["result",6]],[[["parsestream",6]],["result",6]],[[["parsestream",6]],["result",6]],[[["parsestream",6]],["result",6]],[[["parsestream",6]],["result",6]],[[["parsestream",6]],["result",6]],[[["parsestream",6]],["result",6]],[[["parsestream",6]],["result",6]],[[["parsestream",6]],["result",6]],[[["parsestream",6]],["result",6]],[[["parsestream",6]],["result",6]],[[["parsestream",6]],["result",6]],[[["parsestream",6]],["result",6]],[[["parsestream",6]],["result",6]],[[["parsestream",6]],["result",6]],[[["parsestream",6]],["result",6]],[[["parsestream",6]],["result",6]],[[["parsestream",6]],["result",6]],[[["parsestream",6]],["result",6]],[[["parsestream",6]],["result",6]],[[["parsestream",6]],["result",6]],[[]],[[["selfvalue",3]],["ident",3]],[[["selftype",3]],["ident",3]],[[["super",3]],["ident",3]],[[["crate",3]],["ident",3]],[[["extern",3]],["ident",3]],[[["underscore",3]],["ident",3]],[[["path",3]],["meta",4]],[[["metalist",3]],["meta",4]],[[["metanamevalue",3]],["meta",4]],[[["meta",4]],["nestedmeta",4]],[[["lit",4]],["nestedmeta",4]],[[["fieldsnamed",3]],["fields",4]],[[["fieldsunnamed",3]],["fields",4]],[[["vispublic",3]],["visibility",4]],[[["viscrate",3]],["visibility",4]],[[["visrestricted",3]],["visibility",4]],[[["exprarray",3]],["expr",4]],[[["exprassign",3]],["expr",4]],[[["exprassignop",3]],["expr",4]],[[["exprasync",3]],["expr",4]],[[["exprawait",3]],["expr",4]],[[["exprbinary",3]],["expr",4]],[[["exprblock",3]],["expr",4]],[[["exprbox",3]],["expr",4]],[[["exprbreak",3]],["expr",4]],[[["exprcall",3]],["expr",4]],[[["exprcast",3]],["expr",4]],[[["exprclosure",3]],["expr",4]],[[["exprcontinue",3]],["expr",4]],[[["exprfield",3]],["expr",4]],[[["exprforloop",3]],["expr",4]],[[["exprgroup",3]],["expr",4]],[[["exprif",3]],["expr",4]],[[["exprindex",3]],["expr",4]],[[["exprlet",3]],["expr",4]],[[["exprlit",3]],["expr",4]],[[["exprloop",3]],["expr",4]],[[["exprmacro",3]],["expr",4]],[[["exprmatch",3]],["expr",4]],[[["exprmethodcall",3]],["expr",4]],[[["exprparen",3]],["expr",4]],[[["exprpath",3]],["expr",4]],[[["exprrange",3]],["expr",4]],[[["exprreference",3]],["expr",4]],[[["exprrepeat",3]],["expr",4]],[[["exprreturn",3]],["expr",4]],[[["exprstruct",3]],["expr",4]],[[["exprtry",3]],["expr",4]],[[["exprtryblock",3]],["expr",4]],[[["exprtuple",3]],["expr",4]],[[["exprtype",3]],["expr",4]],[[["exprunary",3]],["expr",4]],[[["exprunsafe",3]],["expr",4]],[[["exprwhile",3]],["expr",4]],[[["expryield",3]],["expr",4]],[[["ident",3]],["member",4]],[[["index",3]],["member",4]],[[["usize",15]],["member",4]],[[["usize",15]],["index",3]],[[["typeparam",3]],["genericparam",4]],[[["lifetimedef",3]],["genericparam",4]],[[["constparam",3]],["genericparam",4]],[[["ident",3]]],[[["traitbound",3]],["typeparambound",4]],[[["lifetime",3]],["typeparambound",4]],[[["predicatetype",3]],["wherepredicate",4]],[[["predicatelifetime",3]],["wherepredicate",4]],[[["predicateeq",3]],["wherepredicate",4]],[[["litstr",3]],["lit",4]],[[["litbytestr",3]],["lit",4]],[[["litbyte",3]],["lit",4]],[[["litchar",3]],["lit",4]],[[["litint",3]],["lit",4]],[[["litfloat",3]],["lit",4]],[[["litbool",3]],["lit",4]],[[["literal",3]]],[[["literal",3]]],[[["datastruct",3]],["data",4]],[[["dataenum",3]],["data",4]],[[["dataunion",3]],["data",4]],[[["typearray",3]],["type",4]],[[["typebarefn",3]],["type",4]],[[["typegroup",3]],["type",4]],[[["typeimpltrait",3]],["type",4]],[[["typeinfer",3]],["type",4]],[[["typemacro",3]],["type",4]],[[["typenever",3]],["type",4]],[[["typeparen",3]],["type",4]],[[["typepath",3]],["type",4]],[[["typeptr",3]],["type",4]],[[["typereference",3]],["type",4]],[[["typeslice",3]],["type",4]],[[["typetraitobject",3]],["type",4]],[[["typetuple",3]],["type",4]],[[]],[[]],[[["lexerror",3]]],[[],["option",4]],[[],["option",4]],[[],["option",4]],[[],["option",4]],[[],["option",4]],[[],["option",4]],[[],["usize",15]],[[],["usize",15]],[[],["usize",15]],[[],["usize",15]],[[],["usize",15]],[[],["usize",15]],[[["intoiterator",8]]],[[["intoiterator",8]]],[[["intoiterator",8]]],[[]],[[]],[[]],[[],["option",4]],[[]],[[],["option",4]],[[]],[[],["option",4]],[[]],[[],["option",4]],[[]],[[],["option",4]],[[]],[[],["option",4]],[[]],[[]],[[]],[[]],[[]],[[]],[[]],[[]],[[]],[[]],[[]],[[]],[[]],[[]],[[]],[[]],[[]],[[]],[[]],[[]],[[]],[[]],[[]],[[]],[[]],[[]],[[]],[[]],[[]],[[]],[[]],[[]],[[]],[[]],[[]],[[]],[[]],[[]],[[]],[[]],[[]],[[]],[[]],[[]],[[]],[[]],[[]],[[]],[[]],[[]],[[]],[[]],[[]],[[]],[[]],[[]],[[]],[[]],[[]],[[]],[[]],[[]],[[]],[[]],[[]],[[]],[[]],[[]],[[]],[[]],[[]],[[]],[[]],[[]],[[]],[[]],[[]],[[]],[[]],[[]],[[]],[[]],[[]],[[]],[[]],[[]],[[]],[[]],[[]],[[]],[[]],[[]],[[]],[[]],[[]],[[]],[[]],[[]],[[]],[[]],[[]],[[]],[[]],[[]],[[]],[[]],[[]],[[]],[[]],[[]],[[]],[[]],[[]],[[]],[[]],[[]],[[]],[[]],[[]],[[]],[[]],[[]],[[]],[[]],[[]],[[]],[[]],[[]],[[]],[[]],[[]],[[]],[[]],[[]],[[]],[[]],[[]],[[]],[[]],[[]],[[]],[[]],[[]],[[]],[[]],[[]],[[]],[[]],[[]],[[]],[[]],[[]],[[]],[[]],[[]],[[]],[[]],[[]],[[]],[[]],[[]],[[]],[[]],[[]],[[]],[[]],[[]],[[]],[[]],[[]],[[]],[[]],[[]],[[]],[[]],[[]],[[]],[[]],[[]],[[]],[[]],[[]],[[]],[[]],[[]],[[]],[[]],[[]],[[]],[[]],[[]],[[]],[[]],[[]],[[]],[[]],[[]],[[]],[[]],[[]],[[]],[[]],[[]],[[]],[[]],[[]],[[]],[[]],[[]],[[]],[[]],[[]],[[]],[[]],[[]],[[]],[[]],[[]],[[]],[[]],[[]],[[]],[[]],[[]],[[]],[[]],[[]],[[]],[[]],[[]],[[]],[[]],[[]],[[]],[[]],[[]],[[]],[[]],[[]],[[]],[[]],[[]],[[]],[[]],[[]],[[]],[[]],[[]],[[]],[[]],[[]],[[]],[[]],[[]],[[]],[[]],[[]],[[]],[[]],[[]],[[]],[[]],[[]],[[]],[[]],[[]],[[]],[[]],[[]],[[]],[[]],[[]],[[]],[[]],[[]],[[]],[[]],[[]],[[]],[[]],[[]],[[]],[[]],[[]],[[]],[[]],[[]],[[]],[[]],[[]],[[]],[[]],[[]],[[]],[[]],[[]],[[]],[[]],[[]],[[]],[[]],[[]],[[]],[[]],[[]],[[]],[[]],[[]],[[]],[[]],[[["lifetime",3]],["ordering",4]],[[["underscore",3]],["bool",15]],[[["abstract",3]],["bool",15]],[[["as",3]],["bool",15]],[[["async",3]],["bool",15]],[[["auto",3]],["bool",15]],[[["await",3]],["bool",15]],[[["become",3]],["bool",15]],[[["box",3]],["bool",15]],[[["break",3]],["bool",15]],[[["const",3]],["bool",15]],[[["continue",3]],["bool",15]],[[["crate",3]],["bool",15]],[[["default",3]],["bool",15]],[[["do",3]],["bool",15]],[[["dyn",3]],["bool",15]],[[["else",3]],["bool",15]],[[["enum",3]],["bool",15]],[[["extern",3]],["bool",15]],[[["final",3]],["bool",15]],[[["fn",3]],["bool",15]],[[["for",3]],["bool",15]],[[["if",3]],["bool",15]],[[["impl",3]],["bool",15]],[[["in",3]],["bool",15]],[[["let",3]],["bool",15]],[[["loop",3]],["bool",15]],[[["macro",3]],["bool",15]],[[["match",3]],["bool",15]],[[["mod",3]],["bool",15]],[[["move",3]],["bool",15]],[[["mut",3]],["bool",15]],[[["override",3]],["bool",15]],[[["priv",3]],["bool",15]],[[["pub",3]],["bool",15]],[[["ref",3]],["bool",15]],[[["return",3]],["bool",15]],[[["selftype",3]],["bool",15]],[[["selfvalue",3]],["bool",15]],[[["static",3]],["bool",15]],[[["struct",3]],["bool",15]],[[["super",3]],["bool",15]],[[["trait",3]],["bool",15]],[[["try",3]],["bool",15]],[[["type",3]],["bool",15]],[[["typeof",3]],["bool",15]],[[["union",3]],["bool",15]],[[["unsafe",3]],["bool",15]],[[["unsized",3]],["bool",15]],[[["use",3]],["bool",15]],[[["virtual",3]],["bool",15]],[[["where",3]],["bool",15]],[[["while",3]],["bool",15]],[[["yield",3]],["bool",15]],[[["add",3]],["bool",15]],[[["addeq",3]],["bool",15]],[[["and",3]],["bool",15]],[[["andand",3]],["bool",15]],[[["andeq",3]],["bool",15]],[[["at",3]],["bool",15]],[[["bang",3]],["bool",15]],[[["caret",3]],["bool",15]],[[["careteq",3]],["bool",15]],[[["colon",3]],["bool",15]],[[["colon2",3]],["bool",15]],[[["comma",3]],["bool",15]],[[["div",3]],["bool",15]],[[["diveq",3]],["bool",15]],[[["dollar",3]],["bool",15]],[[["dot",3]],["bool",15]],[[["dot2",3]],["bool",15]],[[["dot3",3]],["bool",15]],[[["dotdoteq",3]],["bool",15]],[[["eq",3]],["bool",15]],[[["eqeq",3]],["bool",15]],[[["ge",3]],["bool",15]],[[["gt",3]],["bool",15]],[[["le",3]],["bool",15]],[[["lt",3]],["bool",15]],[[["muleq",3]],["bool",15]],[[["ne",3]],["bool",15]],[[["or",3]],["bool",15]],[[["oreq",3]],["bool",15]],[[["oror",3]],["bool",15]],[[["pound",3]],["bool",15]],[[["question",3]],["bool",15]],[[["rarrow",3]],["bool",15]],[[["larrow",3]],["bool",15]],[[["rem",3]],["bool",15]],[[["remeq",3]],["bool",15]],[[["fatarrow",3]],["bool",15]],[[["semi",3]],["bool",15]],[[["shl",3]],["bool",15]],[[["shleq",3]],["bool",15]],[[["shr",3]],["bool",15]],[[["shreq",3]],["bool",15]],[[["star",3]],["bool",15]],[[["sub",3]],["bool",15]],[[["subeq",3]],["bool",15]],[[["tilde",3]],["bool",15]],[[["brace",3]],["bool",15]],[[["bracket",3]],["bool",15]],[[["paren",3]],["bool",15]],[[["group",3]],["bool",15]],[[],["bool",15]],[[],["bool",15]],[[],["bool",15]],[[],["bool",15]],[[],["bool",15]],[[["lifetime",3]],["bool",15]],[[],["bool",15]],[[],["bool",15]],[[],["bool",15]],[[],["bool",15]],[[],["bool",15]],[[],["bool",15]],[[],["bool",15]],[[],["bool",15]],[[],["bool",15]],[[],["bool",15]],[[],["bool",15]],[[],["bool",15]],[[],["bool",15]],[[],["bool",15]],[[],["bool",15]],[[],["bool",15]],[[],["bool",15]],[[],["bool",15]],[[],["bool",15]],[[],["bool",15]],[[],["bool",15]],[[],["bool",15]],[[],["bool",15]],[[],["bool",15]],[[],["bool",15]],[[],["bool",15]],[[],["bool",15]],[[],["bool",15]],[[],["bool",15]],[[],["bool",15]],[[],["bool",15]],[[],["bool",15]],[[],["bool",15]],[[],["bool",15]],[[],["bool",15]],[[],["bool",15]],[[],["bool",15]],[[],["bool",15]],[[],["bool",15]],[[],["bool",15]],[[],["bool",15]],[[],["bool",15]],[[],["bool",15]],[[],["bool",15]],[[],["bool",15]],[[],["bool",15]],[[],["bool",15]],[[],["bool",15]],[[],["bool",15]],[[],["bool",15]],[[],["bool",15]],[[],["bool",15]],[[],["bool",15]],[[],["bool",15]],[[],["bool",15]],[[],["bool",15]],[[],["bool",15]],[[],["bool",15]],[[],["bool",15]],[[],["bool",15]],[[],["bool",15]],[[],["bool",15]],[[],["bool",15]],[[],["bool",15]],[[],["bool",15]],[[],["bool",15]],[[],["bool",15]],[[],["bool",15]],[[],["bool",15]],[[],["bool",15]],[[],["bool",15]],[[],["bool",15]],[[],["bool",15]],[[],["bool",15]],[[],["bool",15]],[[],["bool",15]],[[],["bool",15]],[[],["bool",15]],[[],["bool",15]],[[],["bool",15]],[[],["bool",15]],[[],["bool",15]],[[],["bool",15]],[[],["bool",15]],[[],["bool",15]],[[],["bool",15]],[[["lifetime",3]],[["option",4],["ordering",4]]],[[]],[[]],[[]],[[]],[[]],[[]],[[]],[[]],[[]],[[]],[[]],[[]],[[]],[[]],[[]],[[]],[[]],[[]],[[]],[[]],[[]],[[]],[[]],[[]],[[]],[[]],[[]],[[]],[[]],[[]],[[]],[[]],[[]],[[]],[[]],[[]],[[]],[[]],[[]],[[]],[[]],[[]],[[]],[[]],[[]],[[["formatter",3]],["result",6]],[[["formatter",3]],["result",6]],[[["formatter",3]],["result",6]],[[["formatter",3]],["result",6]],[[["formatter",3]],["result",6]],[[["formatter",3]],["result",6]],[[["formatter",3]],["result",6]],[[["formatter",3]],["result",6]],[[["formatter",3]],["result",6]],[[["formatter",3]],["result",6]],[[["formatter",3]],["result",6]],[[["formatter",3]],["result",6]],[[["formatter",3]],["result",6]],[[["formatter",3]],["result",6]],[[["formatter",3]],["result",6]],[[["formatter",3]],["result",6]],[[["formatter",3]],["result",6]],[[["formatter",3]],["result",6]],[[["formatter",3]],["result",6]],[[["formatter",3]],["result",6]],[[["formatter",3]],["result",6]],[[["formatter",3]],["result",6]],[[["formatter",3]],["result",6]],[[["formatter",3]],["result",6]],[[["formatter",3]],["result",6]],[[["formatter",3]],["result",6]],[[["formatter",3]],["result",6]],[[["formatter",3]],["result",6]],[[["formatter",3]],["result",6]],[[["formatter",3]],["result",6]],[[["formatter",3]],["result",6]],[[["formatter",3]],["result",6]],[[["formatter",3]],["result",6]],[[["formatter",3]],["result",6]],[[["formatter",3]],["result",6]],[[["formatter",3]],["result",6]],[[["formatter",3]],["result",6]],[[["formatter",3]],["result",6]],[[["formatter",3]],["result",6]],[[["formatter",3]],["result",6]],[[["formatter",3]],["result",6]],[[["formatter",3]],["result",6]],[[["formatter",3]],["result",6]],[[["formatter",3]],["result",6]],[[["formatter",3]],["result",6]],[[["formatter",3]],["result",6]],[[["formatter",3]],["result",6]],[[["formatter",3]],["result",6]],[[["formatter",3]],["result",6]],[[["formatter",3]],["result",6]],[[["formatter",3]],["result",6]],[[["formatter",3]],["result",6]],[[["formatter",3]],["result",6]],[[["formatter",3]],["result",6]],[[["formatter",3]],["result",6]],[[["formatter",3]],["result",6]],[[["formatter",3]],["result",6]],[[["formatter",3]],["result",6]],[[["formatter",3]],["result",6]],[[["formatter",3]],["result",6]],[[["formatter",3]],["result",6]],[[["formatter",3]],["result",6]],[[["formatter",3]],["result",6]],[[["formatter",3]],["result",6]],[[["formatter",3]],["result",6]],[[["formatter",3]],["result",6]],[[["formatter",3]],["result",6]],[[["formatter",3]],["result",6]],[[["formatter",3]],["result",6]],[[["formatter",3]],["result",6]],[[["formatter",3]],["result",6]],[[["formatter",3]],["result",6]],[[["formatter",3]],["result",6]],[[["formatter",3]],["result",6]],[[["formatter",3]],["result",6]],[[["formatter",3]],["result",6]],[[["formatter",3]],["result",6]],[[["formatter",3]],["result",6]],[[["formatter",3]],["result",6]],[[["formatter",3]],["result",6]],[[["formatter",3]],["result",6]],[[["formatter",3]],["result",6]],[[["formatter",3]],["result",6]],[[["formatter",3]],["result",6]],[[["formatter",3]],["result",6]],[[["formatter",3]],["result",6]],[[["formatter",3]],["result",6]],[[["formatter",3]],["result",6]],[[["formatter",3]],["result",6]],[[["formatter",3]],["result",6]],[[["formatter",3]],["result",6]],[[["formatter",3]],["result",6]],[[["formatter",3]],["result",6]],[[["formatter",3]],["result",6]],[[["formatter",3]],["result",6]],[[["formatter",3]],["result",6]],[[["formatter",3]],["result",6]],[[["formatter",3]],["result",6]],[[["formatter",3]],["result",6]],[[["formatter",3]],["result",6]],[[["formatter",3]],["result",6]],[[["formatter",3]],["result",6]],[[["formatter",3]],["result",6]],[[["formatter",3]],["result",6]],[[["formatter",3]],["result",6]],[[["formatter",3]],["result",6]],[[["formatter",3]],["result",6]],[[["formatter",3]],["result",6]],[[["formatter",3]],["result",6]],[[["formatter",3]],["result",6]],[[["formatter",3]],["result",6]],[[["formatter",3]],["result",6]],[[["formatter",3]],["result",6]],[[["formatter",3]],["result",6]],[[["formatter",3]],["result",6]],[[["formatter",3]],["result",6]],[[["formatter",3]],["result",6]],[[["formatter",3]],["result",6]],[[["formatter",3]],["result",6]],[[["formatter",3]],["result",6]],[[["formatter",3]],["result",6]],[[["formatter",3]],["result",6]],[[["formatter",3]],["result",6]],[[["formatter",3]],["result",6]],[[["formatter",3]],["result",6]],[[["formatter",3]],["result",6]],[[["formatter",3]],["result",6]],[[["formatter",3]],["result",6]],[[["formatter",3]],["result",6]],[[["formatter",3]],["result",6]],[[["formatter",3]],["result",6]],[[["formatter",3]],["result",6]],[[["formatter",3]],["result",6]],[[["formatter",3]],["result",6]],[[["formatter",3]],["result",6]],[[["formatter",3]],["result",6]],[[["formatter",3]],["result",6]],[[["formatter",3]],["result",6]],[[["formatter",3]],["result",6]],[[["formatter",3]],["result",6]],[[["formatter",3]],["result",6]],[[["formatter",3]],["result",6]],[[["formatter",3]],["result",6]],[[["formatter",3]],["result",6]],[[["formatter",3]],["result",6]],[[["formatter",3]],["result",6]],[[["formatter",3]],["result",6]],[[["formatter",3]],["result",6]],[[["formatter",3]],["result",6]],[[["formatter",3]],["result",6]],[[["formatter",3]],["result",6]],[[["formatter",3]],["result",6]],[[["formatter",3]],["result",6]],[[["formatter",3]],["result",6]],[[["formatter",3]],["result",6]],[[["formatter",3]],["result",6]],[[["formatter",3]],["result",6]],[[["formatter",3]],["result",6]],[[["formatter",3]],["result",6]],[[["formatter",3]],["result",6]],[[["formatter",3]],["result",6]],[[["formatter",3]],["result",6]],[[["formatter",3]],["result",6]],[[["formatter",3]],["result",6]],[[["formatter",3]],["result",6]],[[["formatter",3]],["result",6]],[[["formatter",3]],["result",6]],[[["formatter",3]],["result",6]],[[["formatter",3]],["result",6]],[[["formatter",3]],["result",6]],[[["formatter",3]],["result",6]],[[["formatter",3]],["result",6]],[[["formatter",3]],["result",6]],[[["formatter",3]],["result",6]],[[["formatter",3]],["result",6]],[[["formatter",3]],["result",6]],[[["formatter",3]],["result",6]],[[["formatter",3]],["result",6]],[[["formatter",3]],["result",6]],[[["formatter",3]],["result",6]],[[["formatter",3]],["result",6]],[[["formatter",3]],["result",6]],[[["formatter",3]],["result",6]],[[["formatter",3]],["result",6]],[[["formatter",3]],["result",6]],[[["formatter",3]],["result",6]],[[["formatter",3]],["result",6]],[[["formatter",3]],["result",6]],[[["formatter",3]],["result",6]],[[["formatter",3]],["result",6]],[[["formatter",3]],["result",6]],[[["formatter",3]],["result",6]],[[["formatter",3]],["result",6]],[[["formatter",3]],["result",6]],[[["formatter",3]],["result",6]],[[["formatter",3]],["result",6]],[[["formatter",3]],["result",6]],[[["formatter",3]],["result",6]],[[["formatter",3]],["result",6]],[[["formatter",3]],["result",6]],[[["formatter",3]],["result",6]],[[["usize",15]]],[[["usize",15]]],[[]],[[]],[[]],[[]],[[]],[[]],[[]],[[]],[[]],[[]],[[]],[[]],[[]],[[]],[[]],[[]],[[]],[[]],[[]],[[]],[[]],[[]],[[]],[[]],[[]],[[]],[[]],[[]],[[]],[[]],[[]],[[]],[[]],[[]],[[]],[[]],[[]],[[]],[[]],[[]],[[]],[[]],[[]],[[]],[[]],[[]],[[]],[[]],[[]],[[]],[[]],[[]],[[]],[[]],[[]],[[]],[[]],[[]],[[]],[[]],[[]],[[]],[[]],[[]],[[]],[[]],[[]],[[]],[[]],[[]],[[]],[[]],[[]],[[]],[[]],[[]],[[]],[[]],[[]],[[]],[[]],[[]],[[]],[[]],[[]],[[]],[[]],[[]],[[]],[[]],[[]],[[]],[[]],[[]],[[]],[[]],[[]],[[]],[[]],[[]],[[]],[[]],[[]],[[]],[[]],[[]],[[]],[[]],[[]],[[]],[[]],[[]],[[]],[[]],[[]],[[]],[[]],[[]],[[]],[[]],[[]],[[]],[[]],[[]],[[]],[[]],[[]],[[]],[[]],[[]],[[]],[[]],[[]],[[]],[[]],[[]],[[]],[[]],[[]],[[]],[[]],[[]],[[]],[[]],[[]],[[]],[[]],[[]],[[]],[[]],[[]],[[]],[[]],[[]],[[]],[[]],[[]],[[]],[[]],[[]],[[]],[[]],[[]],[[]],[[]],[[]],[[]],[[]],[[]],[[]],[[]],[[]],[[]],[[]],[[]],[[]],[[]],[[]],[[]],[[]],[[]],[[]],[[]],[[]],[[]],[[]],[[]],[[]],[[]],[[]],[[]],[[]],[[]],[[]],[[["intoiterator",8]]],[[["intoiterator",8]]],[[["tokenstream",3]]],[[["tokenstream",3]]],[[["tokenstream",3]]],[[["tokenstream",3]]],[[["tokenstream",3]]],[[["tokenstream",3]]],[[["tokenstream",3]]],[[["tokenstream",3]]],[[["tokenstream",3]]],[[["tokenstream",3]]],[[["tokenstream",3]]],[[["tokenstream",3]]],[[["tokenstream",3]]],[[["tokenstream",3]]],[[["tokenstream",3]]],[[["tokenstream",3]]],[[["tokenstream",3]]],[[["tokenstream",3]]],[[["tokenstream",3]]],[[["tokenstream",3]]],[[["tokenstream",3]]],[[["tokenstream",3]]],[[["tokenstream",3]]],[[["tokenstream",3]]],[[["tokenstream",3]]],[[["tokenstream",3]]],[[["tokenstream",3]]],[[["tokenstream",3]]],[[["tokenstream",3]]],[[["tokenstream",3]]],[[["tokenstream",3]]],[[["tokenstream",3]]],[[["tokenstream",3]]],[[["tokenstream",3]]],[[["tokenstream",3]]],[[["tokenstream",3]]],[[["tokenstream",3]]],[[["tokenstream",3]]],[[["tokenstream",3]]],[[["tokenstream",3]]],[[["tokenstream",3]]],[[["tokenstream",3]]],[[["tokenstream",3]]],[[["tokenstream",3]]],[[["tokenstream",3]]],[[["tokenstream",3]]],[[["tokenstream",3]]],[[["tokenstream",3]]],[[["tokenstream",3]]],[[["tokenstream",3]]],[[["tokenstream",3]]],[[["tokenstream",3]]],[[["tokenstream",3]]],[[["tokenstream",3]]],[[["tokenstream",3]]],[[["tokenstream",3]]],[[["tokenstream",3]]],[[["tokenstream",3]]],[[["tokenstream",3]]],[[["tokenstream",3]]],[[["tokenstream",3]]],[[["tokenstream",3]]],[[["tokenstream",3]]],[[["tokenstream",3]]],[[["tokenstream",3]]],[[["tokenstream",3]]],[[["tokenstream",3]]],[[["tokenstream",3]]],[[["tokenstream",3]]],[[["tokenstream",3]]],[[["tokenstream",3]]],[[["tokenstream",3]]],[[["tokenstream",3]]],[[["tokenstream",3]]],[[["tokenstream",3]]],[[["tokenstream",3]]],[[["tokenstream",3]]],[[["tokenstream",3]]],[[["tokenstream",3]]],[[["tokenstream",3]]],[[["tokenstream",3]]],[[["tokenstream",3]]],[[["tokenstream",3]]],[[["tokenstream",3]]],[[["tokenstream",3]]],[[["tokenstream",3]]],[[["tokenstream",3]]],[[["tokenstream",3]]],[[["tokenstream",3]]],[[["tokenstream",3]]],[[["tokenstream",3]]],[[["tokenstream",3]]],[[["tokenstream",3]]],[[["tokenstream",3]]],[[["tokenstream",3]]],[[["tokenstream",3]]],[[["tokenstream",3]]],[[["tokenstream",3]]],[[["tokenstream",3]]],[[["tokenstream",3]]],[[["tokenstream",3]]],[[["tokenstream",3]]],[[["tokenstream",3]]],[[["tokenstream",3]]],[[["tokenstream",3]]],[[["tokenstream",3]]],[[["tokenstream",3]]],[[["tokenstream",3]]],[[["tokenstream",3]]],[[["tokenstream",3]]],[[["tokenstream",3]]],[[["tokenstream",3]]],[[["tokenstream",3]]],[[["tokenstream",3]]],[[["tokenstream",3]]],[[["tokenstream",3]]],[[["tokenstream",3]]],[[["tokenstream",3]]],[[["tokenstream",3]]],[[["tokenstream",3]]],[[["tokenstream",3]]],[[["tokenstream",3]]],[[["tokenstream",3]]],[[["tokenstream",3]]],[[["tokenstream",3]]],[[["tokenstream",3]]],[[["tokenstream",3]]],[[["tokenstream",3]]],[[["tokenstream",3]]],[[["tokenstream",3]]],[[["tokenstream",3]]],[[["tokenstream",3]]],[[["tokenstream",3]]],[[["tokenstream",3]]],[[["tokenstream",3]]],[[["tokenstream",3]]],[[["tokenstream",3]]],[[["tokenstream",3]]],[[["tokenstream",3]]],[[["tokenstream",3]]],[[["tokenstream",3]]],[[["tokenstream",3]]],[[["tokenstream",3]]],[[["tokenstream",3]]],[[["tokenstream",3]]],[[["tokenstream",3]]],[[["tokenstream",3]]],[[["tokenstream",3]]],[[["tokenstream",3]]],[[["tokenstream",3]]],[[["tokenstream",3]]],[[["tokenstream",3]]],[[["tokenstream",3]]],[[["tokenstream",3]]],[[["tokenstream",3]]],[[["tokenstream",3]]],[[["tokenstream",3]]],[[["tokenstream",3]]],[[["tokenstream",3]]],[[["tokenstream",3]]],[[["tokenstream",3]]],[[["tokenstream",3]]],[[["tokenstream",3]]],[[["tokenstream",3]]],[[["tokenstream",3]]],[[["tokenstream",3]]],[[["tokenstream",3]]],[[["tokenstream",3]]],[[["tokenstream",3]]],[[["tokenstream",3]]],[[["tokenstream",3]]],[[["tokenstream",3]]],[[["tokenstream",3]]],[[["tokenstream",3]]],[[["tokenstream",3]]],[[["tokenstream",3]]],[[["tokenstream",3]]],[[["tokenstream",3]]],[[["tokenstream",3]]],[[["tokenstream",3]]],[[["tokenstream",3]]],[[["tokenstream",3]]],[[["tokenstream",3]]],[[["tokenstream",3]]],[[["tokenstream",3]]],[[["tokenstream",3]]],[[["tokenstream",3]]],[[["tokenstream",3]]],[[["tokenstream",3]]],[[["tokenstream",3]]],[[["tokenstream",3]]],[[["tokenstream",3]]],[[["tokenstream",3]]],[[["tokenstream",3]]],[[["tokenstream",3]]],[[["tokenstream",3]]],[[["tokenstream",3]]],[[["tokenstream",3]]],[[["tokenstream",3]]],[[["tokenstream",3]]],[[["tokenstream",3]]],[[["tokenstream",3]]],[[["tokenstream",3]]],[[["tokenstream",3]]],[[["tokenstream",3]]],[[["tokenstream",3]]],[[["tokenstream",3]]],[[["tokenstream",3]]],[[["tokenstream",3]]],[[["tokenstream",3]]],[[["tokenstream",3]]],[[["tokenstream",3]]],[[["tokenstream",3]]],[[["tokenstream",3]]],[[["formatter",3]],["result",6]],[[],[["option",4],["span",3]]],[[["formatter",3]],["result",6]],[[],[["option",4],["span",3]]],[[["span",3],["str",15]],["ident",3]],[[],["span",3]],[[["span",3]]],[[],[["meta",4],["result",6]]],[[],[["result",6],["parse",8]]],[[["parser",8]],["result",6]],[[["parsestream",6]],[["vec",3],["result",6]]],[[["parsestream",6]],[["vec",3],["result",6]]],[[],["path",3]],[[["parsestream",6]],["result",6]],[[["parsestream",6]],["result",6]],[[],[["iter",3],["field",3]]],[[],[["itermut",3],["field",3]]],[[],["usize",15]],[[],["bool",15]],[[],["typeparams",3]],[[],["typeparamsmut",3]],[[],["lifetimes",3]],[[],["lifetimesmut",3]],[[],["constparams",3]],[[],["constparamsmut",3]],[[],["whereclause",3]],[[]],[[],["turbofish",3]],[[["lifetime",3]]],[[["span",3],["str",15]]],[[],["span",3]],[[["span",3]]],[[["literal",3]]],[[],["str",15]],[[],["span",3]],[[["span",3]]],[[["span",3],["str",15]]],[[],["string",3]],[[],[["result",6],["parse",8]]],[[["parser",8]],["result",6]],[[],["span",3]],[[["span",3]]],[[],["str",15]],[[["span",3]]],[[],[["vec",3],["u8",15]]],[[],["span",3]],[[["span",3]]],[[],["str",15]],[[["span",3],["u8",15]]],[[],["u8",15]],[[],["span",3]],[[["span",3]]],[[],["str",15]],[[["span",3],["char",15]]],[[],["char",15]],[[],["span",3]],[[["span",3]]],[[],["str",15]],[[["span",3],["str",15]]],[[],["str",15]],[[],["result",6]],[[],["str",15]],[[],["span",3]],[[["span",3]]],[[["span",3],["str",15]]],[[],["str",15]],[[],["result",6]],[[],["str",15]],[[],["span",3]],[[["span",3]]],[[["bool",15],["span",3]]],[[],["bool",15]],[[],["span",3]],[[["span",3]]],[[],[["result",6],["parse",8]]],[[["parser",8]],["result",6]],[[["parsestream",6]],["result",6]],[[["parsestream",6]],["result",6]],[[["parsestream",6]],["result",6]],[[["parsestream",6]],["result",6]],[[],["bool",15]],[[],[["ident",3],["option",4]]],[[],["bool",15]],[[["abi",3]]],[[["anglebracketedgenericarguments",3]]],[[["attrstyle",4]]],[[["attribute",3]]],[[["barefnarg",3]]],[[["binop",4]]],[[["binding",3]]],[[["boundlifetimes",3]]],[[["constparam",3]]],[[["constraint",3]]],[[["data",4]]],[[["dataenum",3]]],[[["datastruct",3]]],[[["dataunion",3]]],[[["deriveinput",3]]],[[["expr",4]]],[[["exprbinary",3]]],[[["exprcall",3]]],[[["exprcast",3]]],[[["exprfield",3]]],[[["exprindex",3]]],[[["exprlit",3]]],[[["exprparen",3]]],[[["exprpath",3]]],[[["exprunary",3]]],[[["field",3]]],[[["fields",4]]],[[["fieldsnamed",3]]],[[["fieldsunnamed",3]]],[[["genericargument",4]]],[[["genericparam",4]]],[[["generics",3]]],[[["ident",3]]],[[["index",3]]],[[["lifetime",3]]],[[["lifetimedef",3]]],[[["lit",4]]],[[["litbool",3]]],[[["litbyte",3]]],[[["litbytestr",3]]],[[["litchar",3]]],[[["litfloat",3]]],[[["litint",3]]],[[["litstr",3]]],[[["macro",3]]],[[["macrodelimiter",4]]],[[["member",4]]],[[["meta",4]]],[[["metalist",3]]],[[["metanamevalue",3]]],[[["nestedmeta",4]]],[[["parenthesizedgenericarguments",3]]],[[["path",3]]],[[["patharguments",4]]],[[["pathsegment",3]]],[[["predicateeq",3]]],[[["predicatelifetime",3]]],[[["predicatetype",3]]],[[["qself",3]]],[[["returntype",4]]],[[["span",3]]],[[["traitbound",3]]],[[["traitboundmodifier",4]]],[[["type",4]]],[[["typearray",3]]],[[["typebarefn",3]]],[[["typegroup",3]]],[[["typeimpltrait",3]]],[[["typeinfer",3]]],[[["typemacro",3]]],[[["typenever",3]]],[[["typeparam",3]]],[[["typeparambound",4]]],[[["typeparen",3]]],[[["typepath",3]]],[[["typeptr",3]]],[[["typereference",3]]],[[["typeslice",3]]],[[["typetraitobject",3]]],[[["typetuple",3]]],[[["unop",4]]],[[["variadic",3]]],[[["variant",3]]],[[["viscrate",3]]],[[["vispublic",3]]],[[["visrestricted",3]]],[[["visibility",4]]],[[["whereclause",3]]],[[["wherepredicate",4]]],[[["peek",8]],["bool",15]],[[],["error",3]]],"p":[[3,"Underscore"],[3,"Abstract"],[3,"As"],[3,"Async"],[3,"Auto"],[3,"Await"],[3,"Become"],[3,"Box"],[3,"Break"],[3,"Const"],[3,"Continue"],[3,"Crate"],[3,"Default"],[3,"Do"],[3,"Dyn"],[3,"Else"],[3,"Enum"],[3,"Extern"],[3,"Final"],[3,"Fn"],[3,"For"],[3,"If"],[3,"Impl"],[3,"In"],[3,"Let"],[3,"Loop"],[3,"Macro"],[3,"Match"],[3,"Mod"],[3,"Move"],[3,"Mut"],[3,"Override"],[3,"Priv"],[3,"Pub"],[3,"Ref"],[3,"Return"],[3,"SelfType"],[3,"SelfValue"],[3,"Static"],[3,"Struct"],[3,"Super"],[3,"Trait"],[3,"Try"],[3,"Type"],[3,"Typeof"],[3,"Union"],[3,"Unsafe"],[3,"Unsized"],[3,"Use"],[3,"Virtual"],[3,"Where"],[3,"While"],[3,"Yield"],[3,"Add"],[3,"AddEq"],[3,"And"],[3,"AndAnd"],[3,"AndEq"],[3,"At"],[3,"Bang"],[3,"Caret"],[3,"CaretEq"],[3,"Colon"],[3,"Colon2"],[3,"Comma"],[3,"Div"],[3,"DivEq"],[3,"Dollar"],[3,"Dot"],[3,"Dot2"],[3,"Dot3"],[3,"DotDotEq"],[3,"Eq"],[3,"EqEq"],[3,"Ge"],[3,"Gt"],[3,"Le"],[3,"Lt"],[3,"MulEq"],[3,"Ne"],[3,"Or"],[3,"OrEq"],[3,"OrOr"],[3,"Pound"],[3,"Question"],[3,"RArrow"],[3,"LArrow"],[3,"Rem"],[3,"RemEq"],[3,"FatArrow"],[3,"Semi"],[3,"Shl"],[3,"ShlEq"],[3,"Shr"],[3,"ShrEq"],[3,"Star"],[3,"Sub"],[3,"SubEq"],[3,"Tilde"],[3,"Brace"],[3,"Bracket"],[3,"Paren"],[3,"Group"],[3,"TokenBuffer"],[3,"Cursor"],[8,"IdentExt"],[3,"Punctuated"],[4,"Pair"],[8,"Spanned"],[8,"Visit"],[8,"Speculative"],[8,"Parse"],[3,"StepCursor"],[3,"ParseBuffer"],[8,"Parser"],[3,"Error"],[4,"AttrStyle"],[3,"Attribute"],[4,"Meta"],[3,"MetaList"],[3,"MetaNameValue"],[4,"NestedMeta"],[3,"Field"],[4,"Fields"],[3,"FieldsNamed"],[3,"FieldsUnnamed"],[3,"Variant"],[3,"VisCrate"],[3,"VisPublic"],[3,"VisRestricted"],[4,"Visibility"],[4,"Expr"],[3,"ExprBinary"],[3,"ExprCall"],[3,"ExprCast"],[3,"ExprField"],[3,"ExprIndex"],[3,"ExprLit"],[3,"ExprParen"],[3,"ExprPath"],[3,"ExprUnary"],[3,"Index"],[4,"Member"],[3,"BoundLifetimes"],[3,"ConstParam"],[4,"GenericParam"],[3,"Generics"],[3,"LifetimeDef"],[3,"PredicateEq"],[3,"PredicateLifetime"],[3,"PredicateType"],[3,"TraitBound"],[4,"TraitBoundModifier"],[3,"TypeParam"],[4,"TypeParamBound"],[3,"WhereClause"],[4,"WherePredicate"],[3,"Lifetime"],[4,"Lit"],[3,"LitBool"],[4,"StrStyle"],[3,"Macro"],[4,"MacroDelimiter"],[4,"Data"],[3,"DataEnum"],[3,"DataStruct"],[3,"DataUnion"],[3,"DeriveInput"],[4,"BinOp"],[4,"UnOp"],[3,"Abi"],[3,"BareFnArg"],[4,"ReturnType"],[4,"Type"],[3,"TypeArray"],[3,"TypeBareFn"],[3,"TypeGroup"],[3,"TypeImplTrait"],[3,"TypeInfer"],[3,"TypeMacro"],[3,"TypeNever"],[3,"TypeParen"],[3,"TypePath"],[3,"TypePtr"],[3,"TypeReference"],[3,"TypeSlice"],[3,"TypeTraitObject"],[3,"TypeTuple"],[3,"Variadic"],[3,"AngleBracketedGenericArguments"],[3,"Binding"],[3,"Constraint"],[4,"GenericArgument"],[3,"ParenthesizedGenericArguments"],[3,"Path"],[4,"PathArguments"],[3,"PathSegment"],[3,"QSelf"],[3,"Ident"],[3,"ExprArray"],[3,"ExprAssign"],[3,"ExprAssignOp"],[3,"ExprAsync"],[3,"ExprAwait"],[3,"ExprBlock"],[3,"ExprBox"],[3,"ExprBreak"],[3,"ExprClosure"],[3,"ExprContinue"],[3,"ExprForLoop"],[3,"ExprGroup"],[3,"ExprIf"],[3,"ExprLet"],[3,"ExprLoop"],[3,"ExprMacro"],[3,"ExprMatch"],[3,"ExprMethodCall"],[3,"ExprRange"],[3,"ExprReference"],[3,"ExprRepeat"],[3,"ExprReturn"],[3,"ExprStruct"],[3,"ExprTry"],[3,"ExprTryBlock"],[3,"ExprTuple"],[3,"ExprType"],[3,"ExprUnsafe"],[3,"ExprWhile"],[3,"ExprYield"],[3,"ImplGenerics"],[3,"TypeGenerics"],[3,"Turbofish"],[3,"LitStr"],[3,"LitByteStr"],[3,"LitByte"],[3,"LitChar"],[3,"LitInt"],[3,"LitFloat"],[3,"Pairs"],[3,"PairsMut"],[3,"IntoPairs"],[3,"IntoIter"],[3,"Iter"],[3,"IterMut"],[3,"Lookahead1"],[3,"Nothing"]]},\ +"synstructure":{"doc":"This crate provides helper types for matching against …","t":[4,13,13,13,13,4,13,13,13,13,3,12,12,11,11,11,3,12,12,12,12,3,12,11,11,11,11,11,11,11,11,11,11,11,11,11,3,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,5,8,10,11,14,14,14,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11],"n":["AddBounds","Both","Fields","Generics","None","BindStyle","Move","MoveMut","Ref","RefMut","BindingInfo","binding","style","ast","pat","referenced_ty_params","VariantAst","attrs","ident","fields","discriminant","VariantInfo","prefix","bindings","bindings_mut","ast","omitted_bindings","pat","construct","each","fold","filter","remove_binding","bind_with","binding_name","referenced_ty_params","Structure","new","try_new","variants","variants_mut","ast","omitted_variants","each","fold","each_variant","filter","add_where_predicate","add_bounds","filter_variants","remove_variant","bind_with","binding_name","referenced_ty_params","add_impl_generic","add_trait_bounds","underscore_const","bound_impl","unsafe_bound_impl","unbound_impl","unsafe_unbound_impl","gen_impl","unpretty_print","MacroResult","into_result","into_stream","decl_derive","decl_attribute","test_derive","from","into","to_owned","clone_into","borrow","borrow_mut","try_from","try_into","type_id","from","into","to_owned","clone_into","borrow","borrow_mut","try_from","try_into","type_id","span","from","into","to_owned","clone_into","borrow","borrow_mut","try_from","try_into","type_id","span","from","into","to_owned","clone_into","borrow","borrow_mut","try_from","try_into","type_id","from","into","to_owned","clone_into","borrow","borrow_mut","try_from","try_into","type_id","from","into","to_owned","clone_into","borrow","borrow_mut","try_from","try_into","type_id","clone","clone","clone","clone","clone","clone","eq","eq","eq","ne","eq","ne","eq","ne","eq","ne","fmt","fmt","fmt","fmt","fmt","fmt","hash","hash","hash","hash","hash","hash","to_tokens","to_tokens"],"q":["synstructure","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","",""],"d":["Changes how bounds are added","Add for fields and generics","Fields only","Generics only","None","The type of binding to use when generating a pattern.","x","mut x","ref x","ref mut x","Information about a specific binding. This contains both …","The name which this BindingInfo will bind to.","The type of binding which this BindingInfo will create.","Returns a reference to the underlying syn AST node which …","Generates the pattern fragment for this field binding.","Returns a list of the type parameters which are …","This type is similar to syn’s Variant type, however …","","","","","A wrapper around a syn::DeriveInput’s variant which …","","Returns a slice of the bindings in this Variant.","Returns a mut slice of the bindings in this Variant.","Returns a VariantAst object which contains references to …","True if any bindings were omitted due to a filter call.","Generates the match-arm pattern which could be used to …","Generates the token stream required to construct the …","Runs the passed-in function once for each bound field, …","Runs the passed-in function once for each bound field, …","Filter the bindings created by this Variant object. This …","Remove the binding at the given index.","Updates the BindStyle for each of the passed-in fields by …","Updates the binding name for each fo the passed-in fields …","Returns a list of the type parameters which are …","A wrapper around a syn::DeriveInput which provides …","Create a new Structure with the variants and fields from …","Create a new Structure with the variants and fields from …","Returns a slice of the variants in this Structure.","Returns a mut slice of the variants in this Structure.","Returns a reference to the underlying syn AST node which …","True if any variants were omitted due to a filter_variants…","Runs the passed-in function once for each bound field, …","Runs the passed-in function once for each bound field, …","Runs the passed-in function once for each variant, …","Filter the bindings created by this Structure object. …","Specify additional where predicate bounds which should be …","Specify which bounds should be generated by …","Filter the variants matched by this Structure object. …","Remove the variant at the given index.","Updates the BindStyle for each of the passed-in fields by …","Updates the binding name for each fo the passed-in fields …","Returns a list of the type parameters which are refrenced …","Adds an impl<> generic parameter. This can be used when …","Add trait bounds for a trait with the given path for each …","Configure whether to use const _ instead of a generated …","NOTE: This methods’ features are superceded by …","NOTE: This methods’ features are superceded by …","NOTE: This methods’ features are superceded by …","NOTE: This methods’ features are superceded by …","Generate an impl block for the given struct. This impl …","Dumps an unpretty version of a tokenstream. Takes any …","Helper trait describing values which may be returned by …","Convert this result into a Result for further processing …","Convert this result into a proc_macro::TokenStream, ready …","The decl_derive! macro declares a custom derive wrapper. …","The decl_attribute! macro declares a custom attribute …","Run a test on a custom derive. This macro expands both …","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","",""],"i":[0,1,1,1,1,0,2,2,2,2,0,3,3,3,3,3,0,4,4,4,4,0,5,5,5,5,5,5,5,5,5,5,5,5,5,5,0,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,0,0,7,7,0,0,0,1,1,1,1,1,1,1,1,1,2,2,2,2,2,2,2,2,2,2,3,3,3,3,3,3,3,3,3,3,4,4,4,4,4,4,4,4,4,5,5,5,5,5,5,5,5,5,6,6,6,6,6,6,6,6,6,1,2,3,4,5,6,1,2,3,3,4,4,5,5,6,6,1,2,3,4,5,6,1,2,3,4,5,6,2,3],"f":[null,null,null,null,null,null,null,null,null,null,null,null,null,[[],["field",3]],[[],["tokenstream",3]],[[],[["ident",3],["vec",3]]],null,null,null,null,null,null,null,[[]],[[]],[[],["variantast",3]],[[],["bool",15]],[[],["tokenstream",3]],[[],["tokenstream",3]],[[],["tokenstream",3]],[[],["tokenstream",3]],[[]],[[["usize",15]]],[[]],[[]],[[],[["ident",3],["vec",3]]],null,[[["deriveinput",3]]],[[["deriveinput",3]],["result",6]],[[]],[[]],[[],["deriveinput",3]],[[],["bool",15]],[[],["tokenstream",3]],[[],["tokenstream",3]],[[],["tokenstream",3]],[[]],[[["wherepredicate",4]]],[[["addbounds",4]]],[[]],[[["usize",15]]],[[]],[[]],[[],[["ident",3],["vec",3]]],[[["genericparam",4]]],[[["addbounds",4],["traitbound",3],["option",4]]],[[["bool",15]]],[[["totokens",8]],["tokenstream",3]],[[["totokens",8]],["tokenstream",3]],[[["totokens",8]],["tokenstream",3]],[[["totokens",8]],["tokenstream",3]],[[["tokenstream",3]],["tokenstream",3]],[[["display",8]],["string",3]],null,[[],[["tokenstream",3],["result",6]]],[[],["tokenstream",3]],null,null,null,[[]],[[]],[[]],[[]],[[]],[[]],[[],["result",4]],[[],["result",4]],[[],["typeid",3]],[[]],[[]],[[]],[[]],[[]],[[]],[[],["result",4]],[[],["result",4]],[[],["typeid",3]],[[],["span",3]],[[]],[[]],[[]],[[]],[[]],[[]],[[],["result",4]],[[],["result",4]],[[],["typeid",3]],[[],["span",3]],[[]],[[]],[[]],[[]],[[]],[[]],[[],["result",4]],[[],["result",4]],[[],["typeid",3]],[[]],[[]],[[]],[[]],[[]],[[]],[[],["result",4]],[[],["result",4]],[[],["typeid",3]],[[]],[[]],[[]],[[]],[[]],[[]],[[],["result",4]],[[],["result",4]],[[],["typeid",3]],[[],["addbounds",4]],[[],["bindstyle",4]],[[],["bindinginfo",3]],[[],["variantast",3]],[[],["variantinfo",3]],[[],["structure",3]],[[["addbounds",4]],["bool",15]],[[["bindstyle",4]],["bool",15]],[[["bindinginfo",3]],["bool",15]],[[["bindinginfo",3]],["bool",15]],[[["variantast",3]],["bool",15]],[[["variantast",3]],["bool",15]],[[["variantinfo",3]],["bool",15]],[[["variantinfo",3]],["bool",15]],[[["structure",3]],["bool",15]],[[["structure",3]],["bool",15]],[[["formatter",3]],["result",6]],[[["formatter",3]],["result",6]],[[["formatter",3]],["result",6]],[[["formatter",3]],["result",6]],[[["formatter",3]],["result",6]],[[["formatter",3]],["result",6]],[[]],[[]],[[]],[[]],[[]],[[]],[[["tokenstream",3]]],[[["tokenstream",3]]]],"p":[[4,"AddBounds"],[4,"BindStyle"],[3,"BindingInfo"],[3,"VariantAst"],[3,"VariantInfo"],[3,"Structure"],[8,"MacroResult"]]},\ +"unicode_xid":{"doc":"Determine if a char is a valid identifier for a parser …","t":[17,8,10,10],"n":["UNICODE_VERSION","UnicodeXID","is_xid_start","is_xid_continue"],"q":["unicode_xid","","",""],"d":["The version of Unicode that this version of unicode-xid …","Methods for determining if a character is a valid …","Returns whether the specified character satisfies the ‘…","Returns whether the specified char satisfies the ‘…"],"i":[0,0,1,1],"f":[null,null,[[],["bool",15]],[[],["bool",15]]],"p":[[8,"UnicodeXID"]]}\ }'); -addSearchOptions(searchIndex);initSearch(searchIndex); \ No newline at end of file +initSearch(searchIndex); \ No newline at end of file diff --git a/settings.html b/settings.html index ce2f5d2..c3d864f 100644 --- a/settings.html +++ b/settings.html @@ -1,6 +1,7 @@ -Rustdoc settings +Rustdoc settings -

Rustdoc settings

Theme preferences
Use system theme
Preferred dark theme
Preferred light theme
+

Rustdoc settings

Theme preferences
Use system theme
Preferred dark theme
Preferred light theme
Auto-hide item declarations
Auto-hide structs declaration
Auto-hide enums declaration
Auto-hide unions declaration
Auto-hide traits declaration
Auto-hide macros declaration
-
Auto-hide item attributes.
Auto-hide item methods' documentation
Auto-hide trait implementation documentation
Auto-hide implementors of a trait
Directly go to item in search if there is only one result
Show line numbers on code examples
Disable keyboard shortcuts
\ No newline at end of file +
Auto-hide item attributes.
Auto-hide item methods' documentation
Auto-hide trait implementation documentation
Auto-hide implementors of a trait
Directly go to item in search if there is only one result
Show line numbers on code examples
Disable keyboard shortcuts
+ \ No newline at end of file diff --git a/source-script.js b/source-script.js index de663ca..67f62a1 100644 --- a/source-script.js +++ b/source-script.js @@ -1 +1 @@ -function getCurrentFilePath(){var parts=window.location.pathname.split("/");var rootPathParts=window.rootPath.split("/");for(var i=0;i"){sidebar.style.left="";this.style.left="";child.innerText="<";updateLocalStorage("rustdoc-source-sidebar-show","true")}else{sidebar.style.left="-300px";this.style.left="0";child.innerText=">";updateLocalStorage("rustdoc-source-sidebar-show","false")}}function createSidebarToggle(){var sidebarToggle=document.createElement("div");sidebarToggle.id="sidebar-toggle";sidebarToggle.onclick=toggleSidebar;var inner1=document.createElement("div");inner1.style.position="relative";var inner2=document.createElement("div");inner2.style.paddingTop="3px";if(getCurrentValue("rustdoc-source-sidebar-show")==="true"){inner2.innerText="<"}else{inner2.innerText=">";sidebarToggle.style.left="0"}inner1.appendChild(inner2);sidebarToggle.appendChild(inner1);return sidebarToggle}function createSourceSidebar(){if(window.rootPath.endsWith("/")===false){window.rootPath+="/"}var main=document.getElementById("main");var sidebarToggle=createSidebarToggle();main.insertBefore(sidebarToggle,main.firstChild);var sidebar=document.createElement("div");sidebar.id="source-sidebar";if(getCurrentValue("rustdoc-source-sidebar-show")!=="true"){sidebar.style.left="-300px"}var currentFile=getCurrentFilePath();var hasFoundFile=false;var title=document.createElement("div");title.className="title";title.innerText="Files";sidebar.appendChild(title);Object.keys(sourcesIndex).forEach(function(key){sourcesIndex[key].name=key;hasFoundFile=createDirEntry(sourcesIndex[key],sidebar,"",currentFile,hasFoundFile)});main.insertBefore(sidebar,main.firstChild);var selected_elem=sidebar.getElementsByClassName("selected")[0];if(typeof selected_elem!=="undefined"){selected_elem.focus()}} \ No newline at end of file +function getCurrentFilePath(){var parts=window.location.pathname.split("/");var rootPathParts=window.rootPath.split("/");for(var i=0,len=rootPathParts.length;i"){sidebar.style.left="";this.style.left="";child.innerText="<";updateLocalStorage("rustdoc-source-sidebar-show","true")}else{sidebar.style.left="-300px";this.style.left="0";child.innerText=">";updateLocalStorage("rustdoc-source-sidebar-show","false")}}function createSidebarToggle(){var sidebarToggle=document.createElement("div");sidebarToggle.id="sidebar-toggle";sidebarToggle.onclick=toggleSidebar;var inner1=document.createElement("div");inner1.style.position="relative";var inner2=document.createElement("div");inner2.style.paddingTop="3px";if(getCurrentValue("rustdoc-source-sidebar-show")==="true"){inner2.innerText="<"}else{inner2.innerText=">";sidebarToggle.style.left="0"}inner1.appendChild(inner2);sidebarToggle.appendChild(inner1);return sidebarToggle}function createSourceSidebar(){if(window.rootPath.endsWith("/")===false){window.rootPath+="/"}var main=document.getElementById("main");var sidebarToggle=createSidebarToggle();main.insertBefore(sidebarToggle,main.firstChild);var sidebar=document.createElement("div");sidebar.id="source-sidebar";if(getCurrentValue("rustdoc-source-sidebar-show")!=="true"){sidebar.style.left="-300px"}var currentFile=getCurrentFilePath();var hasFoundFile=false;var title=document.createElement("div");title.className="title";title.innerText="Files";sidebar.appendChild(title);Object.keys(sourcesIndex).forEach(function(key){sourcesIndex[key].name=key;hasFoundFile=createDirEntry(sourcesIndex[key],sidebar,"",currentFile,hasFoundFile)});main.insertBefore(sidebar,main.firstChild);var selected_elem=sidebar.getElementsByClassName("selected")[0];if(typeof selected_elem!=="undefined"){selected_elem.focus()}} \ No newline at end of file diff --git a/src/cfg_if/lib.rs.html b/src/cfg_if/lib.rs.html index fbc2960..4913ec6 100644 --- a/src/cfg_if/lib.rs.html +++ b/src/cfg_if/lib.rs.html @@ -1,7 +1,7 @@ -lib.rs - source +lib.rs - source -
  1
+
  1
   2
   3
   4
@@ -355,4 +355,5 @@
     }
 }
 

-

\ No newline at end of file
+
+ \ No newline at end of file diff --git a/src/delog/hex.rs.html b/src/delog/hex.rs.html index 4090f03..6579640 100644 --- a/src/delog/hex.rs.html +++ b/src/delog/hex.rs.html @@ -1,7 +1,7 @@ -hex.rs - source +hex.rs - source -
  1
+
  1
   2
   3
   4
@@ -619,4 +619,5 @@
 
 }
 

-

\ No newline at end of file
+
+ \ No newline at end of file diff --git a/src/delog/lib.rs.html b/src/delog/lib.rs.html index 02129bf..9082d0a 100644 --- a/src/delog/lib.rs.html +++ b/src/delog/lib.rs.html @@ -1,7 +1,7 @@ -lib.rs - source +lib.rs - source -
  1
+
  1
   2
   3
   4
@@ -371,4 +371,5 @@
 }
 
 

-

\ No newline at end of file
+
+ \ No newline at end of file diff --git a/src/delog/logger.rs.html b/src/delog/logger.rs.html index 5b58809..59592c9 100644 --- a/src/delog/logger.rs.html +++ b/src/delog/logger.rs.html @@ -1,7 +1,7 @@ -logger.rs - source +logger.rs - source -
  1
+
  1
   2
   3
   4
@@ -582,6 +582,21 @@
 579
 580
 581
+582
+583
+584
+585
+586
+587
+588
+589
+590
+591
+592
+593
+594
+595
+596
 
 use core::{cmp, ptr};
 use core::sync::atomic::{AtomicUsize, Ordering};
@@ -687,8 +702,19 @@
 #[cfg(not(any(feature = "max_level_off", all(not(debug_assertions), feature = "release_max_level_off"))))]
 #[macro_export]
 macro_rules! delog {
+    ($logger:ident, $capacity:expr, $render_capacity:expr, $flusher:ty) => {
+        delog!($logger, $capacity, $render_capacity, $flusher, renderer: $crate::render::DefaultRenderer);
+
+        impl $logger {
+            #[inline]
+            pub fn init_default(level: $crate::log::LevelFilter, flusher: &'static $flusher) -> Result<(), ()> {
+                $logger::init(level, flusher, $crate::render::default())
+            }
+        }
+    };
+
     ($logger:ident, $capacity:expr, $flusher:ty) => {
-        delog!($logger, $capacity, $flusher, renderer: $crate::render::DefaultRenderer);
+        delog!($logger, $capacity, $capacity, $flusher, renderer: $crate::render::DefaultRenderer);
 
         impl $logger {
             #[inline]
@@ -699,6 +725,10 @@
     };
 
     ($logger:ident, $capacity:expr, $flusher:ty, renderer: $renderer:ty) => {
+        $crate::delog!($logger, $capacity, $capacity, $flusher, renderer: $renderer);
+    };
+
+    ($logger:ident, $capacity:expr, $render_capacity:expr, $flusher:ty, renderer: $renderer:ty) => {
 
         #[derive(Clone, Copy)]
         /// Generated deferred logging implementation.
@@ -852,7 +882,7 @@
             }
 
             fn render(&self, record: &$crate::Record) -> &'static [u8] {
-                static mut LOCAL_BUFFER: [u8; $capacity] = [0u8; $capacity];
+                static mut LOCAL_BUFFER: [u8; $render_capacity] = [0u8; $render_capacity];
 
                 let local_buffer = unsafe { &mut LOCAL_BUFFER };
                 use $crate::Renderer;
@@ -1053,10 +1083,10 @@
 
             // try to stake out our claim
             let previous = delogger.claimed()
-                .compare_and_swap(claimed, claimed + size, Ordering::SeqCst);
+                .compare_exchange(claimed, claimed + size, Ordering::SeqCst, Ordering::SeqCst);
 
             // we were not interrupted, the region is now ours
-            if previous == claimed {
+            if previous == Ok(claimed) {
                 break claimed;
             }
         };
@@ -1165,4 +1195,5 @@
     }
 }
 

-

\ No newline at end of file
+
+ \ No newline at end of file diff --git a/src/delog/macros.rs.html b/src/delog/macros.rs.html index e5050a3..722cace 100644 --- a/src/delog/macros.rs.html +++ b/src/delog/macros.rs.html @@ -1,7 +1,7 @@ -macros.rs - source +macros.rs - source -
  1
+
  1
   2
   3
   4
@@ -480,7 +480,7 @@
 
                 #[macro_use] #[macro_export]
                 /// Local version of `trace!`.
-                macro_rules! trace { ($d($arg:tt)+) => ( $try_trace!($d($arg)+).ok() ); }
+                macro_rules! trace { ($d($arg:tt)+) => ( try_trace!($d($arg)+).ok() ); }
 
                 #[macro_use] #[macro_export]
                 /// Local version of `warn!`.
@@ -543,4 +543,5 @@
     }
 }
 

-

\ No newline at end of file
+
+ \ No newline at end of file diff --git a/src/delog/render.rs.html b/src/delog/render.rs.html index 3625d96..761ac48 100644 --- a/src/delog/render.rs.html +++ b/src/delog/render.rs.html @@ -1,7 +1,7 @@ -render.rs - source +render.rs - source -
  1
+
  1
   2
   3
   4
@@ -106,6 +106,8 @@
 103
 104
 105
+106
+107
 
 //! The default, minimal renderer, and some helper functions.
 
@@ -151,8 +153,10 @@
     }
 
     pub fn endl(&mut self) {
-        self.buffer[self.used] = b'\n';
-        self.used += 1;
+        if self.used < self.buffer.len() {
+            self.buffer[self.used] = b'\n';
+            self.used += 1;
+        }
     }
 }
 
@@ -165,7 +169,7 @@
         let raw_s = s.as_bytes();
         let write_num = cmp::min(raw_s.len(), remaining_buf.len());
         remaining_buf[..write_num].copy_from_slice(&raw_s[..write_num]);
-        self.used += raw_s.len();
+        self.used += write_num;
         if write_num < raw_s.len() {
             Err(fmt::Error)
         } else {
@@ -213,4 +217,5 @@
     }
 }
 

-

\ No newline at end of file
+
+ \ No newline at end of file diff --git a/src/flexiber/decoder.rs.html b/src/flexiber/decoder.rs.html index 6d63bc6..532b0de 100644 --- a/src/flexiber/decoder.rs.html +++ b/src/flexiber/decoder.rs.html @@ -1,7 +1,7 @@ -decoder.rs - source +decoder.rs - source -
  1
+
  1
   2
   3
   4
@@ -385,4 +385,5 @@
 //     }
 // }
 

-

\ No newline at end of file
+
+ \ No newline at end of file diff --git a/src/flexiber/encoder.rs.html b/src/flexiber/encoder.rs.html index 96d815e..ed5cb47 100644 --- a/src/flexiber/encoder.rs.html +++ b/src/flexiber/encoder.rs.html @@ -1,7 +1,7 @@ -encoder.rs - source +encoder.rs - source -
  1
+
  1
   2
   3
   4
@@ -363,4 +363,5 @@
     // }
 }
 

-

\ No newline at end of file
+
+ \ No newline at end of file diff --git a/src/flexiber/error.rs.html b/src/flexiber/error.rs.html index 4bb6c1d..7d86ece 100644 --- a/src/flexiber/error.rs.html +++ b/src/flexiber/error.rs.html @@ -1,7 +1,7 @@ -error.rs - source +error.rs - source -
  1
+
  1
   2
   3
   4
@@ -487,4 +487,5 @@
     }
 }
 

-

\ No newline at end of file
+
+ \ No newline at end of file diff --git a/src/flexiber/header.rs.html b/src/flexiber/header.rs.html index f2b32eb..e10dd42 100644 --- a/src/flexiber/header.rs.html +++ b/src/flexiber/header.rs.html @@ -1,7 +1,7 @@ -header.rs - source +header.rs - source -
 1
+
 1
  2
  3
  4
@@ -117,4 +117,5 @@
     }
 }
 

-

\ No newline at end of file
+
+ \ No newline at end of file diff --git a/src/flexiber/length.rs.html b/src/flexiber/length.rs.html index 8494bbb..4806de9 100644 --- a/src/flexiber/length.rs.html +++ b/src/flexiber/length.rs.html @@ -1,7 +1,7 @@ -length.rs - source +length.rs - source -
  1
+
  1
   2
   3
   4
@@ -489,4 +489,5 @@
     }
 }
 

-

\ No newline at end of file
+
+ \ No newline at end of file diff --git a/src/flexiber/lib.rs.html b/src/flexiber/lib.rs.html index 2b035ca..468ba26 100644 --- a/src/flexiber/lib.rs.html +++ b/src/flexiber/lib.rs.html @@ -1,7 +1,7 @@ -lib.rs - source +lib.rs - source -
 1
+
 1
  2
  3
  4
@@ -131,4 +131,5 @@
 // }
 
 

-

\ No newline at end of file
+
+ \ No newline at end of file diff --git a/src/flexiber/simpletag.rs.html b/src/flexiber/simpletag.rs.html index 9f6649b..d8e3b41 100644 --- a/src/flexiber/simpletag.rs.html +++ b/src/flexiber/simpletag.rs.html @@ -1,7 +1,7 @@ -simpletag.rs - source +simpletag.rs - source -
 1
+
 1
  2
  3
  4
@@ -147,4 +147,5 @@
     }
 }
 

-

\ No newline at end of file
+
+ \ No newline at end of file diff --git a/src/flexiber/slice.rs.html b/src/flexiber/slice.rs.html index 4350b61..039c443 100644 --- a/src/flexiber/slice.rs.html +++ b/src/flexiber/slice.rs.html @@ -1,7 +1,7 @@ -slice.rs - source +slice.rs - source -
 1
+
 1
  2
  3
  4
@@ -93,4 +93,5 @@
 }
 
 

-

\ No newline at end of file
+
+ \ No newline at end of file diff --git a/src/flexiber/tag.rs.html b/src/flexiber/tag.rs.html index 0840f0e..6e80443 100644 --- a/src/flexiber/tag.rs.html +++ b/src/flexiber/tag.rs.html @@ -1,7 +1,7 @@ -tag.rs - source +tag.rs - source -
  1
+
  1
   2
   3
   4
@@ -501,4 +501,5 @@
     }
 }
 

-

\ No newline at end of file
+
+ \ No newline at end of file diff --git a/src/flexiber/tagged.rs.html b/src/flexiber/tagged.rs.html index f2b72cd..5dfc8f7 100644 --- a/src/flexiber/tagged.rs.html +++ b/src/flexiber/tagged.rs.html @@ -1,7 +1,7 @@ -tagged.rs - source +tagged.rs - source -
  1
+
  1
   2
   3
   4
@@ -423,4 +423,5 @@
 
 }
 

-

\ No newline at end of file
+
+ \ No newline at end of file diff --git a/src/flexiber/traits.rs.html b/src/flexiber/traits.rs.html index c792944..21fc00d 100644 --- a/src/flexiber/traits.rs.html +++ b/src/flexiber/traits.rs.html @@ -1,7 +1,7 @@ -traits.rs - source +traits.rs - source -
  1
+
  1
   2
   3
   4
@@ -780,7 +780,7 @@
 pub trait EncodableHeapless: Encodable {
     /// Encode this message as BER-TLV, appending it to the provided
     /// heapless byte vector.
-    fn encode_to_heapless_vec<N: heapless::ArrayLength<u8>>(&self, buf: &mut heapless::Vec<u8, N>) -> Result<Length> {
+    fn encode_to_heapless_vec<const N: usize>(&self, buf: &mut heapless::Vec<u8, N>) -> Result<Length> {
         let expected_len = self.encoded_length()?.to_usize();
         let current_len = buf.len();
         // TODO(nickray): add a specific error for "Overcapacity" conditional on heapless feature?
@@ -802,7 +802,7 @@
     }
 
     /// Serialize this message as a byte vector.
-    fn to_heapless_vec<N: heapless::ArrayLength<u8>>(&self) -> Result<heapless::Vec<u8, N>> {
+    fn to_heapless_vec<const N: usize>(&self) -> Result<heapless::Vec<u8, N>> {
         let mut buf = heapless::Vec::new();
         self.encode_to_heapless_vec(&mut buf)?;
         Ok(buf)
@@ -1303,4 +1303,5 @@
     }
 }
 

-

\ No newline at end of file
+
+ \ No newline at end of file diff --git a/src/flexiber_derive/decodable.rs.html b/src/flexiber_derive/decodable.rs.html index 9316809..40ab2cb 100644 --- a/src/flexiber_derive/decodable.rs.html +++ b/src/flexiber_derive/decodable.rs.html @@ -1,7 +1,7 @@ -decodable.rs - source +decodable.rs - source -
  1
+
  1
   2
   3
   4
@@ -337,4 +337,5 @@
 }
 
 

-

\ No newline at end of file
+
+ \ No newline at end of file diff --git a/src/flexiber_derive/encodable.rs.html b/src/flexiber_derive/encodable.rs.html index 98facf7..4310141 100644 --- a/src/flexiber_derive/encodable.rs.html +++ b/src/flexiber_derive/encodable.rs.html @@ -1,7 +1,7 @@ -encodable.rs - source +encodable.rs - source -
  1
+
  1
   2
   3
   4
@@ -303,4 +303,5 @@
 }
 
 

-

\ No newline at end of file
+
+ \ No newline at end of file diff --git a/src/flexiber_derive/lib.rs.html b/src/flexiber_derive/lib.rs.html index b8639e5..dd66027 100644 --- a/src/flexiber_derive/lib.rs.html +++ b/src/flexiber_derive/lib.rs.html @@ -1,7 +1,7 @@ -lib.rs - source +lib.rs - source -
  1
+
  1
   2
   3
   4
@@ -563,4 +563,5 @@
     }
 }
 

-

\ No newline at end of file
+
+ \ No newline at end of file diff --git a/src/log/lib.rs.html b/src/log/lib.rs.html index c4629a0..93f9635 100644 --- a/src/log/lib.rs.html +++ b/src/log/lib.rs.html @@ -1,5 +1,5 @@ -lib.rs - source
   1
+lib.rs - source
   1
    2
    3
    4
@@ -3551,4 +3551,5 @@
     }
 }
 

-

\ No newline at end of file
+
+ \ No newline at end of file diff --git a/src/log/macros.rs.html b/src/log/macros.rs.html index e22048e..b560d5a 100644 --- a/src/log/macros.rs.html +++ b/src/log/macros.rs.html @@ -1,5 +1,5 @@ -macros.rs - source
  1
+macros.rs - source
  1
   2
   3
   4
@@ -501,4 +501,5 @@
     };
 }
 

-

\ No newline at end of file
+
+ \ No newline at end of file diff --git a/src/proc_macro2/detection.rs.html b/src/proc_macro2/detection.rs.html index f6803bf..cf98524 100644 --- a/src/proc_macro2/detection.rs.html +++ b/src/proc_macro2/detection.rs.html @@ -1,7 +1,7 @@ -detection.rs - source +detection.rs - source -
 1
+
 1
  2
  3
  4
@@ -137,4 +137,5 @@
     }
 }
 

-

\ No newline at end of file
+
+ \ No newline at end of file diff --git a/src/proc_macro2/fallback.rs.html b/src/proc_macro2/fallback.rs.html index 5635bd9..e46ffce 100644 --- a/src/proc_macro2/fallback.rs.html +++ b/src/proc_macro2/fallback.rs.html @@ -1,7 +1,7 @@ -fallback.rs - source +fallback.rs - source -
  1
+
  1
   2
   3
   4
@@ -901,8 +901,31 @@
 898
 899
 900
+901
+902
+903
+904
+905
+906
+907
+908
+909
+910
+911
+912
+913
+914
+915
+916
+917
+918
+919
+920
+921
+922
+923
 
-use crate::parse::{token_stream, Cursor};
+use crate::parse::{self, Cursor};
 use crate::{Delimiter, Spacing, TokenTree};
 #[cfg(span_locations)]
 use std::cell::RefCell;
@@ -939,7 +962,21 @@
 }
 
 #[derive(Debug)]
-pub(crate) struct LexError;
+pub(crate) struct LexError {
+    pub(crate) span: Span,
+}
+
+impl LexError {
+    pub(crate) fn span(&self) -> Span {
+        self.span
+    }
+
+    fn call_site() -> Self {
+        LexError {
+            span: Span::call_site(),
+        }
+    }
+}
 
 impl TokenStream {
     pub fn new() -> TokenStream {
@@ -1043,12 +1080,7 @@
         // Create a dummy file & add it to the source map
         let cursor = get_cursor(src);
 
-        let (rest, tokens) = token_stream(cursor)?;
-        if rest.is_empty() {
-            Ok(tokens)
-        } else {
-            Err(LexError)
-        }
+        parse::token_stream(cursor)
     }
 }
 
@@ -1788,6 +1820,20 @@
     }
 }
 
+impl FromStr for Literal {
+    type Err = LexError;
+
+    fn from_str(repr: &str) -> Result<Self, Self::Err> {
+        let cursor = get_cursor(repr);
+        if let Ok((_rest, literal)) = parse::literal(cursor) {
+            if literal.text.len() == repr.len() {
+                return Ok(literal);
+            }
+        }
+        Err(LexError::call_site())
+    }
+}
+
 impl Display for Literal {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
         Display::fmt(&self.text, f)
@@ -1803,4 +1849,5 @@
     }
 }
 

-

\ No newline at end of file
+
+ \ No newline at end of file diff --git a/src/proc_macro2/lib.rs.html b/src/proc_macro2/lib.rs.html index 2d62264..be14451 100644 --- a/src/proc_macro2/lib.rs.html +++ b/src/proc_macro2/lib.rs.html @@ -1,7 +1,7 @@ -lib.rs - source +lib.rs - source -
   1
+
   1
    2
    3
    4
@@ -1235,6 +1235,44 @@
 1232
 1233
 1234
+1235
+1236
+1237
+1238
+1239
+1240
+1241
+1242
+1243
+1244
+1245
+1246
+1247
+1248
+1249
+1250
+1251
+1252
+1253
+1254
+1255
+1256
+1257
+1258
+1259
+1260
+1261
+1262
+1263
+1264
+1265
+1266
+1267
+1268
+1269
+1270
+1271
+1272
 
 //! A wrapper around the procedural macro API of the compiler's [`proc_macro`]
 //! crate. This library serves two purposes:
@@ -1316,10 +1354,11 @@
 //! a different thread.
 
 // Proc-macro2 types in rustdoc of other crates get linked to here.
-#![doc(html_root_url = "https://docs.rs/proc-macro2/1.0.24")]
+#![doc(html_root_url = "https://docs.rs/proc-macro2/1.0.27")]
 #![cfg_attr(any(proc_macro_span, super_unstable), feature(proc_macro_span))]
 #![cfg_attr(super_unstable, feature(proc_macro_raw_ident, proc_macro_def_site))]
-#![allow(clippy::needless_doctest_main)]
+#![cfg_attr(doc_cfg, feature(doc_cfg))]
+#![allow(clippy::needless_doctest_main, clippy::vec_init_then_push)]
 
 #[cfg(use_proc_macro)]
 extern crate proc_macro;
@@ -1487,6 +1526,12 @@
     }
 }
 
+impl LexError {
+    pub fn span(&self) -> Span {
+        Span::_new(self.inner.span())
+    }
+}
+
 impl Debug for LexError {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
         Debug::fmt(&self.inner, f)
@@ -1505,6 +1550,7 @@
 ///
 /// This type is semver exempt and not exposed by default.
 #[cfg(procmacro2_semver_exempt)]
+#[cfg_attr(doc_cfg, doc(cfg(procmacro2_semver_exempt)))]
 #[derive(Clone, PartialEq, Eq)]
 pub struct SourceFile {
     inner: imp::SourceFile,
@@ -1555,6 +1601,7 @@
 ///
 /// This type is semver exempt and not exposed by default.
 #[cfg(span_locations)]
+#[cfg_attr(doc_cfg, doc(cfg(feature = "span-locations")))]
 #[derive(Copy, Clone, Debug, PartialEq, Eq)]
 pub struct LineColumn {
     /// The 1-indexed line in the source file on which the span starts or ends
@@ -1626,6 +1673,7 @@
     ///
     /// This method is semver exempt and not exposed by default.
     #[cfg(procmacro2_semver_exempt)]
+    #[cfg_attr(doc_cfg, doc(cfg(procmacro2_semver_exempt)))]
     pub fn def_site() -> Span {
         Span::_new(imp::Span::def_site())
     }
@@ -1668,6 +1716,7 @@
     ///
     /// This method is semver exempt and not exposed by default.
     #[cfg(procmacro2_semver_exempt)]
+    #[cfg_attr(doc_cfg, doc(cfg(procmacro2_semver_exempt)))]
     pub fn source_file(&self) -> SourceFile {
         SourceFile::_new(self.inner.source_file())
     }
@@ -1675,7 +1724,14 @@
     /// Get the starting line/column in the source file for this span.
     ///
     /// This method requires the `"span-locations"` feature to be enabled.
+    ///
+    /// When executing in a procedural macro context, the returned line/column
+    /// are only meaningful if compiled with a nightly toolchain. The stable
+    /// toolchain does not have this information available. When executing
+    /// outside of a procedural macro, such as main.rs or build.rs, the
+    /// line/column are always meaningful regardless of toolchain.
     #[cfg(span_locations)]
+    #[cfg_attr(doc_cfg, doc(cfg(feature = "span-locations")))]
     pub fn start(&self) -> LineColumn {
         let imp::LineColumn { line, column } = self.inner.start();
         LineColumn { line, column }
@@ -1684,7 +1740,14 @@
     /// Get the ending line/column in the source file for this span.
     ///
     /// This method requires the `"span-locations"` feature to be enabled.
+    ///
+    /// When executing in a procedural macro context, the returned line/column
+    /// are only meaningful if compiled with a nightly toolchain. The stable
+    /// toolchain does not have this information available. When executing
+    /// outside of a procedural macro, such as main.rs or build.rs, the
+    /// line/column are always meaningful regardless of toolchain.
     #[cfg(span_locations)]
+    #[cfg_attr(doc_cfg, doc(cfg(feature = "span-locations")))]
     pub fn end(&self) -> LineColumn {
         let imp::LineColumn { line, column } = self.inner.end();
         LineColumn { line, column }
@@ -1707,6 +1770,7 @@
     ///
     /// This method is semver exempt and not exposed by default.
     #[cfg(procmacro2_semver_exempt)]
+    #[cfg_attr(doc_cfg, doc(cfg(procmacro2_semver_exempt)))]
     pub fn eq(&self, other: &Span) -> bool {
         self.inner.eq(&other.inner)
     }
@@ -1937,7 +2001,7 @@
     }
 }
 
-/// An `Punct` is an single punctuation character like `+`, `-` or `#`.
+/// A `Punct` is a single punctuation character like `+`, `-` or `#`.
 ///
 /// Multicharacter operators like `+=` are represented as two instances of
 /// `Punct` with different forms of `Spacing` returned.
@@ -1948,7 +2012,7 @@
     span: Span,
 }
 
-/// Whether an `Punct` is followed immediately by another `Punct` or followed by
+/// Whether a `Punct` is followed immediately by another `Punct` or followed by
 /// another token or whitespace.
 #[derive(Copy, Clone, Debug, Eq, PartialEq)]
 pub enum Spacing {
@@ -2137,6 +2201,7 @@
     ///
     /// This method is semver exempt and not exposed by default.
     #[cfg(procmacro2_semver_exempt)]
+    #[cfg_attr(doc_cfg, doc(cfg(procmacro2_semver_exempt)))]
     pub fn new_raw(string: &str, span: Span) -> Ident {
         Ident::_new_raw(string, span)
     }
@@ -2225,7 +2290,7 @@
         /// This function will create an integer like `1u32` where the integer
         /// value specified is the first part of the token and the integral is
         /// also suffixed at the end. Literals created from negative numbers may
-        /// not survive rountrips through `TokenStream` or strings and may be
+        /// not survive roundtrips through `TokenStream` or strings and may be
         /// broken into two tokens (`-` and positive literal).
         ///
         /// Literals created through this method have the `Span::call_site()`
@@ -2246,7 +2311,7 @@
         /// specified on this token, meaning that invocations like
         /// `Literal::i8_unsuffixed(1)` are equivalent to
         /// `Literal::u32_unsuffixed(1)`. Literals created from negative numbers
-        /// may not survive rountrips through `TokenStream` or strings and may
+        /// may not survive roundtrips through `TokenStream` or strings and may
         /// be broken into two tokens (`-` and positive literal).
         ///
         /// Literals created through this method have the `Span::call_site()`
@@ -2414,6 +2479,17 @@
     }
 }
 
+impl FromStr for Literal {
+    type Err = LexError;
+
+    fn from_str(repr: &str) -> Result<Self, LexError> {
+        repr.parse().map(Literal::_new).map_err(|inner| LexError {
+            inner,
+            _marker: Marker,
+        })
+    }
+}
+
 impl Debug for Literal {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
         Debug::fmt(&self.inner, f)
@@ -2471,4 +2547,5 @@
     }
 }
 

-

\ No newline at end of file
+
+ \ No newline at end of file diff --git a/src/proc_macro2/marker.rs.html b/src/proc_macro2/marker.rs.html index bc568b2..5715c66 100644 --- a/src/proc_macro2/marker.rs.html +++ b/src/proc_macro2/marker.rs.html @@ -1,7 +1,7 @@ -marker.rs - source +marker.rs - source -
 1
+
 1
  2
  3
  4
@@ -39,4 +39,5 @@
 impl UnwindSafe for ProcMacroAutoTraits {}
 impl RefUnwindSafe for ProcMacroAutoTraits {}
 

-

\ No newline at end of file
+
+ \ No newline at end of file diff --git a/src/proc_macro2/parse.rs.html b/src/proc_macro2/parse.rs.html index 121f146..993ae77 100644 --- a/src/proc_macro2/parse.rs.html +++ b/src/proc_macro2/parse.rs.html @@ -1,7 +1,7 @@ -parse.rs - source +parse.rs - source -
  1
+
  1
   2
   3
   4
@@ -850,6 +850,23 @@
 847
 848
 849
+850
+851
+852
+853
+854
+855
+856
+857
+858
+859
+860
+861
+862
+863
+864
+865
+866
 
 use crate::fallback::{
     is_ident_continue, is_ident_start, Group, LexError, Literal, Span, TokenStream,
@@ -879,7 +896,7 @@
         self.rest.starts_with(s)
     }
 
-    pub(crate) fn is_empty(&self) -> bool {
+    fn is_empty(&self) -> bool {
         self.rest.is_empty()
     }
 
@@ -903,16 +920,17 @@
         self.rest.char_indices()
     }
 
-    fn parse(&self, tag: &str) -> Result<Cursor<'a>, LexError> {
+    fn parse(&self, tag: &str) -> Result<Cursor<'a>, Reject> {
         if self.starts_with(tag) {
             Ok(self.advance(tag.len()))
         } else {
-            Err(LexError)
+            Err(Reject)
         }
     }
 }
 
-type PResult<'a, O> = Result<(Cursor<'a>, O), LexError>;
+pub(crate) struct Reject;
+type PResult<'a, O> = Result<(Cursor<'a>, O), Reject>;
 
 fn skip_whitespace(input: Cursor) -> Cursor {
     let mut s = input;
@@ -939,7 +957,7 @@
                         s = rest;
                         continue;
                     }
-                    Err(LexError) => return s,
+                    Err(Reject) => return s,
                 }
             }
         }
@@ -964,7 +982,7 @@
 
 fn block_comment(input: Cursor) -> PResult<&str> {
     if !input.starts_with("/*") {
-        return Err(LexError);
+        return Err(Reject);
     }
 
     let mut depth = 0;
@@ -986,7 +1004,7 @@
         i += 1;
     }
 
-    Err(LexError)
+    Err(Reject)
 }
 
 fn is_whitespace(ch: char) -> bool {
@@ -994,14 +1012,14 @@
     ch.is_whitespace() || ch == '\u{200e}' || ch == '\u{200f}'
 }
 
-fn word_break(input: Cursor) -> Result<Cursor, LexError> {
+fn word_break(input: Cursor) -> Result<Cursor, Reject> {
     match input.chars().next() {
-        Some(ch) if is_ident_continue(ch) => Err(LexError),
+        Some(ch) if is_ident_continue(ch) => Err(Reject),
         Some(_) | None => Ok(input),
     }
 }
 
-pub(crate) fn token_stream(mut input: Cursor) -> PResult<TokenStream> {
+pub(crate) fn token_stream(mut input: Cursor) -> Result<TokenStream, LexError> {
     let mut trees = Vec::new();
     let mut stack = Vec::new();
 
@@ -1019,7 +1037,17 @@
 
         let first = match input.bytes().next() {
             Some(first) => first,
-            None => break,
+            None => match stack.last() {
+                None => return Ok(TokenStream { inner: trees }),
+                #[cfg(span_locations)]
+                Some((lo, _frame)) => {
+                    return Err(LexError {
+                        span: Span { lo: *lo, hi: *lo },
+                    })
+                }
+                #[cfg(not(span_locations))]
+                Some(_frame) => return Err(LexError { span: Span {} }),
+            },
         };
 
         if let Some(open_delimiter) = match first {
@@ -1040,14 +1068,17 @@
             b'}' => Some(Delimiter::Brace),
             _ => None,
         } {
-            input = input.advance(1);
-            let frame = stack.pop().ok_or(LexError)?;
+            let frame = match stack.pop() {
+                Some(frame) => frame,
+                None => return Err(lex_error(input)),
+            };
             #[cfg(span_locations)]
             let (lo, frame) = frame;
             let (open_delimiter, outer) = frame;
             if open_delimiter != close_delimiter {
-                return Err(LexError);
+                return Err(lex_error(input));
             }
+            input = input.advance(1);
             let mut g = Group::new(open_delimiter, TokenStream { inner: trees });
             g.set_span(Span {
                 #[cfg(span_locations)]
@@ -1058,7 +1089,10 @@
             trees = outer;
             trees.push(TokenTree::Group(crate::Group::_new_stable(g)));
         } else {
-            let (rest, mut tt) = leaf_token(input)?;
+            let (rest, mut tt) = match leaf_token(input) {
+                Ok((rest, tt)) => (rest, tt),
+                Err(Reject) => return Err(lex_error(input)),
+            };
             tt.set_span(crate::Span::_new_stable(Span {
                 #[cfg(span_locations)]
                 lo,
@@ -1069,11 +1103,18 @@
             input = rest;
         }
     }
+}
 
-    if stack.is_empty() {
-        Ok((input, TokenStream { inner: trees }))
-    } else {
-        Err(LexError)
+fn lex_error(cursor: Cursor) -> LexError {
+    #[cfg(not(span_locations))]
+    let _ = cursor;
+    LexError {
+        span: Span {
+            #[cfg(span_locations)]
+            lo: cursor.off,
+            #[cfg(span_locations)]
+            hi: cursor.off,
+        },
     }
 }
 
@@ -1086,7 +1127,7 @@
     } else if let Ok((input, i)) = ident(input) {
         Ok((input, TokenTree::Ident(i)))
     } else {
-        Err(LexError)
+        Err(Reject)
     }
 }
 
@@ -1095,7 +1136,7 @@
         .iter()
         .any(|prefix| input.starts_with(prefix))
     {
-        Err(LexError)
+        Err(Reject)
     } else {
         ident_any(input)
     }
@@ -1113,7 +1154,7 @@
     }
 
     if sym == "_" {
-        return Err(LexError);
+        return Err(Reject);
     }
 
     let ident = crate::Ident::_new_raw(sym, crate::Span::call_site());
@@ -1125,7 +1166,7 @@
 
     match chars.next() {
         Some((_, ch)) if is_ident_start(ch) => {}
-        _ => return Err(LexError),
+        _ => return Err(Reject),
     }
 
     let mut end = input.len();
@@ -1139,17 +1180,13 @@
     Ok((input.advance(end), &input.rest[..end]))
 }
 
-fn literal(input: Cursor) -> PResult<Literal> {
-    match literal_nocapture(input) {
-        Ok(a) => {
-            let end = input.len() - a.len();
-            Ok((a, Literal::_new(input.rest[..end].to_string())))
-        }
-        Err(LexError) => Err(LexError),
-    }
+pub(crate) fn literal(input: Cursor) -> PResult<Literal> {
+    let rest = literal_nocapture(input)?;
+    let end = input.len() - rest.len();
+    Ok((rest, Literal::_new(input.rest[..end].to_string())))
 }
 
-fn literal_nocapture(input: Cursor) -> Result<Cursor, LexError> {
+fn literal_nocapture(input: Cursor) -> Result<Cursor, Reject> {
     if let Ok(ok) = string(input) {
         Ok(ok)
     } else if let Ok(ok) = byte_string(input) {
@@ -1163,28 +1200,28 @@
     } else if let Ok(ok) = int(input) {
         Ok(ok)
     } else {
-        Err(LexError)
+        Err(Reject)
     }
 }
 
 fn literal_suffix(input: Cursor) -> Cursor {
     match ident_not_raw(input) {
         Ok((input, _)) => input,
-        Err(LexError) => input,
+        Err(Reject) => input,
     }
 }
 
-fn string(input: Cursor) -> Result<Cursor, LexError> {
+fn string(input: Cursor) -> Result<Cursor, Reject> {
     if let Ok(input) = input.parse("\"") {
         cooked_string(input)
     } else if let Ok(input) = input.parse("r") {
         raw_string(input)
     } else {
-        Err(LexError)
+        Err(Reject)
     }
 }
 
-fn cooked_string(input: Cursor) -> Result<Cursor, LexError> {
+fn cooked_string(input: Cursor) -> Result<Cursor, Reject> {
     let mut chars = input.char_indices().peekable();
 
     while let Some((i, ch)) = chars.next() {
@@ -1214,7 +1251,7 @@
                     let mut last = ch;
                     loop {
                         if last == '\r' && chars.next().map_or(true, |(_, ch)| ch != '\n') {
-                            return Err(LexError);
+                            return Err(Reject);
                         }
                         match chars.peek() {
                             Some((_, ch)) if ch.is_whitespace() => {
@@ -1230,20 +1267,20 @@
             _ch => {}
         }
     }
-    Err(LexError)
+    Err(Reject)
 }
 
-fn byte_string(input: Cursor) -> Result<Cursor, LexError> {
+fn byte_string(input: Cursor) -> Result<Cursor, Reject> {
     if let Ok(input) = input.parse("b\"") {
         cooked_byte_string(input)
     } else if let Ok(input) = input.parse("br") {
         raw_string(input)
     } else {
-        Err(LexError)
+        Err(Reject)
     }
 }
 
-fn cooked_byte_string(mut input: Cursor) -> Result<Cursor, LexError> {
+fn cooked_byte_string(mut input: Cursor) -> Result<Cursor, Reject> {
     let mut bytes = input.bytes().enumerate();
     while let Some((offset, b)) = bytes.next() {
         match b {
@@ -1269,7 +1306,7 @@
                     let mut chars = rest.char_indices();
                     loop {
                         if last == '\r' && chars.next().map_or(true, |(_, ch)| ch != '\n') {
-                            return Err(LexError);
+                            return Err(Reject);
                         }
                         match chars.next() {
                             Some((_, ch)) if ch.is_whitespace() => last = ch,
@@ -1278,7 +1315,7 @@
                                 bytes = input.bytes().enumerate();
                                 break;
                             }
-                            None => return Err(LexError),
+                            None => return Err(Reject),
                         }
                     }
                 }
@@ -1288,10 +1325,10 @@
             _ => break,
         }
     }
-    Err(LexError)
+    Err(Reject)
 }
 
-fn raw_string(input: Cursor) -> Result<Cursor, LexError> {
+fn raw_string(input: Cursor) -> Result<Cursor, Reject> {
     let mut chars = input.char_indices();
     let mut n = 0;
     while let Some((i, ch)) = chars.next() {
@@ -1301,7 +1338,7 @@
                 break;
             }
             '#' => {}
-            _ => return Err(LexError),
+            _ => return Err(Reject),
         }
     }
     while let Some((i, ch)) = chars.next() {
@@ -1317,10 +1354,10 @@
             _ => {}
         }
     }
-    Err(LexError)
+    Err(Reject)
 }
 
-fn byte(input: Cursor) -> Result<Cursor, LexError> {
+fn byte(input: Cursor) -> Result<Cursor, Reject> {
     let input = input.parse("b'")?;
     let mut bytes = input.bytes().enumerate();
     let ok = match bytes.next().map(|(_, b)| b) {
@@ -1333,17 +1370,17 @@
         b => b.is_some(),
     };
     if !ok {
-        return Err(LexError);
+        return Err(Reject);
     }
-    let (offset, _) = bytes.next().ok_or(LexError)?;
+    let (offset, _) = bytes.next().ok_or(Reject)?;
     if !input.chars().as_str().is_char_boundary(offset) {
-        return Err(LexError);
+        return Err(Reject);
     }
     let input = input.advance(offset).parse("'")?;
     Ok(literal_suffix(input))
 }
 
-fn character(input: Cursor) -> Result<Cursor, LexError> {
+fn character(input: Cursor) -> Result<Cursor, Reject> {
     let input = input.parse("'")?;
     let mut chars = input.char_indices();
     let ok = match chars.next().map(|(_, ch)| ch) {
@@ -1358,9 +1395,9 @@
         ch => ch.is_some(),
     };
     if !ok {
-        return Err(LexError);
+        return Err(Reject);
     }
-    let (idx, _) = chars.next().ok_or(LexError)?;
+    let (idx, _) = chars.next().ok_or(Reject)?;
     let input = input.advance(idx).parse("'")?;
     Ok(literal_suffix(input))
 }
@@ -1402,7 +1439,7 @@
     next_ch!(chars @ '{');
     let mut value = 0;
     let mut len = 0;
-    while let Some((_, ch)) = chars.next() {
+    for (_, ch) in chars {
         let digit = match ch {
             '0'..='9' => ch as u8 - b'0',
             'a'..='f' => 10 + ch as u8 - b'a',
@@ -1421,7 +1458,7 @@
     false
 }
 
-fn float(input: Cursor) -> Result<Cursor, LexError> {
+fn float(input: Cursor) -> Result<Cursor, Reject> {
     let mut rest = float_digits(input)?;
     if let Some(ch) = rest.chars().next() {
         if is_ident_start(ch) {
@@ -1431,11 +1468,11 @@
     word_break(rest)
 }
 
-fn float_digits(input: Cursor) -> Result<Cursor, LexError> {
+fn float_digits(input: Cursor) -> Result<Cursor, Reject> {
     let mut chars = input.chars().peekable();
     match chars.next() {
         Some(ch) if ch >= '0' && ch <= '9' => {}
-        _ => return Err(LexError),
+        _ => return Err(Reject),
     }
 
     let mut len = 1;
@@ -1457,7 +1494,7 @@
                     .map(|&ch| ch == '.' || is_ident_start(ch))
                     .unwrap_or(false)
                 {
-                    return Err(LexError);
+                    return Err(Reject);
                 }
                 len += 1;
                 has_dot = true;
@@ -1473,14 +1510,14 @@
     }
 
     if !(has_dot || has_exp) {
-        return Err(LexError);
+        return Err(Reject);
     }
 
     if has_exp {
         let token_before_exp = if has_dot {
             Ok(input.advance(len - 1))
         } else {
-            Err(LexError)
+            Err(Reject)
         };
         let mut has_sign = false;
         let mut has_exp_value = false;
@@ -1517,7 +1554,7 @@
     Ok(input.advance(len))
 }
 
-fn int(input: Cursor) -> Result<Cursor, LexError> {
+fn int(input: Cursor) -> Result<Cursor, Reject> {
     let mut rest = digits(input)?;
     if let Some(ch) = rest.chars().next() {
         if is_ident_start(ch) {
@@ -1527,7 +1564,7 @@
     word_break(rest)
 }
 
-fn digits(mut input: Cursor) -> Result<Cursor, LexError> {
+fn digits(mut input: Cursor) -> Result<Cursor, Reject> {
     let base = if input.starts_with("0x") {
         input = input.advance(2);
         16
@@ -1548,7 +1585,7 @@
             b'0'..=b'9' => {
                 let digit = (b - b'0') as u64;
                 if digit >= base {
-                    return Err(LexError);
+                    return Err(Reject);
                 }
             }
             b'a'..=b'f' => {
@@ -1565,7 +1602,7 @@
             }
             b'_' => {
                 if empty && base == 10 {
-                    return Err(LexError);
+                    return Err(Reject);
                 }
                 len += 1;
                 continue;
@@ -1576,50 +1613,47 @@
         empty = false;
     }
     if empty {
-        Err(LexError)
+        Err(Reject)
     } else {
         Ok(input.advance(len))
     }
 }
 
 fn punct(input: Cursor) -> PResult<Punct> {
-    match punct_char(input) {
-        Ok((rest, '\'')) => {
-            if ident_any(rest)?.0.starts_with("'") {
-                Err(LexError)
-            } else {
-                Ok((rest, Punct::new('\'', Spacing::Joint)))
-            }
+    let (rest, ch) = punct_char(input)?;
+    if ch == '\'' {
+        if ident_any(rest)?.0.starts_with("'") {
+            Err(Reject)
+        } else {
+            Ok((rest, Punct::new('\'', Spacing::Joint)))
         }
-        Ok((rest, ch)) => {
-            let kind = match punct_char(rest) {
-                Ok(_) => Spacing::Joint,
-                Err(LexError) => Spacing::Alone,
-            };
-            Ok((rest, Punct::new(ch, kind)))
-        }
-        Err(LexError) => Err(LexError),
+    } else {
+        let kind = match punct_char(rest) {
+            Ok(_) => Spacing::Joint,
+            Err(Reject) => Spacing::Alone,
+        };
+        Ok((rest, Punct::new(ch, kind)))
     }
 }
 
 fn punct_char(input: Cursor) -> PResult<char> {
     if input.starts_with("//") || input.starts_with("/*") {
         // Do not accept `/` of a comment as a punct.
-        return Err(LexError);
+        return Err(Reject);
     }
 
     let mut chars = input.chars();
     let first = match chars.next() {
         Some(ch) => ch,
         None => {
-            return Err(LexError);
+            return Err(Reject);
         }
     };
     let recognized = "~!@#$%^&*-=+|;:,<.>/?'";
     if recognized.contains(first) {
         Ok((input.advance(first.len_utf8()), first))
     } else {
-        Err(LexError)
+        Err(Reject)
     }
 }
 
@@ -1638,7 +1672,7 @@
     while let Some(cr) = scan_for_bare_cr.find('\r') {
         let rest = &scan_for_bare_cr[cr + 1..];
         if !rest.starts_with('\n') {
-            return Err(LexError);
+            return Err(Reject);
         }
         scan_for_bare_cr = rest;
     }
@@ -1675,7 +1709,7 @@
     } else if input.starts_with("///") {
         let input = input.advance(3);
         if input.starts_with("/") {
-            return Err(LexError);
+            return Err(Reject);
         }
         let (input, s) = take_until_newline_or_eof(input);
         Ok((input, (s, false)))
@@ -1683,7 +1717,7 @@
         let (input, s) = block_comment(input)?;
         Ok((input, (&s[3..s.len() - 2], false)))
     } else {
-        Err(LexError)
+        Err(Reject)
     }
 }
 
@@ -1701,4 +1735,5 @@
     (input.advance(input.len()), input.rest)
 }
 

-

\ No newline at end of file
+
+ \ No newline at end of file diff --git a/src/proc_macro2/wrapper.rs.html b/src/proc_macro2/wrapper.rs.html index b67ba59..67ac4ed 100644 --- a/src/proc_macro2/wrapper.rs.html +++ b/src/proc_macro2/wrapper.rs.html @@ -1,7 +1,7 @@ -wrapper.rs - source +wrapper.rs - source -
  1
+
  1
   2
   3
   4
@@ -914,6 +914,52 @@
 911
 912
 913
+914
+915
+916
+917
+918
+919
+920
+921
+922
+923
+924
+925
+926
+927
+928
+929
+930
+931
+932
+933
+934
+935
+936
+937
+938
+939
+940
+941
+942
+943
+944
+945
+946
+947
+948
+949
+950
+951
+952
+953
+954
+955
+956
+957
+958
+959
 
 use crate::detection::inside_proc_macro;
 use crate::{fallback, Delimiter, Punct, Spacing, TokenTree};
@@ -946,6 +992,14 @@
     Fallback(fallback::LexError),
 }
 
+impl LexError {
+    fn call_site() -> Self {
+        LexError::Fallback(fallback::LexError {
+            span: fallback::Span::call_site(),
+        })
+    }
+}
+
 fn mismatch() -> ! {
     panic!("stable/nightly mismatch")
 }
@@ -1024,8 +1078,8 @@
 
 // Work around https://github.com/rust-lang/rust/issues/58736.
 fn proc_macro_parse(src: &str) -> Result<proc_macro::TokenStream, LexError> {
-    panic::catch_unwind(|| src.parse().map_err(LexError::Compiler))
-        .unwrap_or(Err(LexError::Fallback(fallback::LexError)))
+    let result = panic::catch_unwind(|| src.parse().map_err(LexError::Compiler));
+    result.unwrap_or_else(|_| Err(LexError::call_site()))
 }
 
 impl Display for TokenStream {
@@ -1160,6 +1214,15 @@
     }
 }
 
+impl LexError {
+    pub(crate) fn span(&self) -> Span {
+        match self {
+            LexError::Compiler(_) => Span::call_site(),
+            LexError::Fallback(e) => Span::Fallback(e.span()),
+        }
+    }
+}
+
 impl From<proc_macro::LexError> for LexError {
     fn from(e: proc_macro::LexError) -> LexError {
         LexError::Compiler(e)
@@ -1187,7 +1250,12 @@
             #[cfg(lexerror_display)]
             LexError::Compiler(e) => Display::fmt(e, f),
             #[cfg(not(lexerror_display))]
-            LexError::Compiler(_e) => Display::fmt(&fallback::LexError, f),
+            LexError::Compiler(_e) => Display::fmt(
+                &fallback::LexError {
+                    span: fallback::Span::call_site(),
+                },
+                f,
+            ),
             LexError::Fallback(e) => Display::fmt(e, f),
         }
     }
@@ -1811,6 +1879,30 @@
     }
 }
 
+impl FromStr for Literal {
+    type Err = LexError;
+
+    fn from_str(repr: &str) -> Result<Self, Self::Err> {
+        if inside_proc_macro() {
+            // TODO: use libproc_macro's FromStr impl once it is available in
+            // rustc. https://github.com/rust-lang/rust/pull/84717
+            let tokens = proc_macro_parse(repr)?;
+            let mut iter = tokens.into_iter();
+            if let (Some(proc_macro::TokenTree::Literal(literal)), None) =
+                (iter.next(), iter.next())
+            {
+                if literal.to_string().len() == repr.len() {
+                    return Ok(Literal::Compiler(literal));
+                }
+            }
+            Err(LexError::call_site())
+        } else {
+            let literal = fallback::Literal::from_str(repr)?;
+            Ok(Literal::Fallback(literal))
+        }
+    }
+}
+
 impl Display for Literal {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
         match self {
@@ -1829,4 +1921,5 @@
     }
 }
 

-

\ No newline at end of file
+
+ \ No newline at end of file diff --git a/src/quote/ext.rs.html b/src/quote/ext.rs.html index ca14b6a..3a88be9 100644 --- a/src/quote/ext.rs.html +++ b/src/quote/ext.rs.html @@ -1,7 +1,7 @@ -ext.rs - source +ext.rs - source -
  1
+
  1
   2
   3
   4
@@ -227,4 +227,5 @@
     impl Sealed for TokenStream {}
 }
 

-

\ No newline at end of file
+
+ \ No newline at end of file diff --git a/src/quote/format.rs.html b/src/quote/format.rs.html index cb627be..1e9d3b8 100644 --- a/src/quote/format.rs.html +++ b/src/quote/format.rs.html @@ -1,7 +1,7 @@ -format.rs - source +format.rs - source -
  1
+
  1
   2
   3
   4
@@ -331,4 +331,5 @@
     };
 }
 

-

\ No newline at end of file
+
+ \ No newline at end of file diff --git a/src/quote/ident_fragment.rs.html b/src/quote/ident_fragment.rs.html index 11c420c..33f7028 100644 --- a/src/quote/ident_fragment.rs.html +++ b/src/quote/ident_fragment.rs.html @@ -1,7 +1,7 @@ -ident_fragment.rs - source +ident_fragment.rs - source -
 1
+
 1
  2
  3
  4
@@ -175,4 +175,5 @@
 ident_fragment_display!(bool, str, String, char);
 ident_fragment_display!(u8, u16, u32, u64, u128, usize);
 

-

\ No newline at end of file
+
+ \ No newline at end of file diff --git a/src/quote/lib.rs.html b/src/quote/lib.rs.html index fc294ed..d0f7917 100644 --- a/src/quote/lib.rs.html +++ b/src/quote/lib.rs.html @@ -1,7 +1,7 @@ -lib.rs - source +lib.rs - source -
   1
+
   1
    2
    3
    4
@@ -2537,4 +2537,5 @@
     };
 }
 

-

\ No newline at end of file
+
+ \ No newline at end of file diff --git a/src/quote/runtime.rs.html b/src/quote/runtime.rs.html index 7c22d8a..37eb353 100644 --- a/src/quote/runtime.rs.html +++ b/src/quote/runtime.rs.html @@ -1,7 +1,7 @@ -runtime.rs - source +runtime.rs - source -
  1
+
  1
   2
   3
   4
@@ -807,4 +807,5 @@
     }
 }
 

-

\ No newline at end of file
+
+ \ No newline at end of file diff --git a/src/quote/spanned.rs.html b/src/quote/spanned.rs.html index 24dbd05..14291a4 100644 --- a/src/quote/spanned.rs.html +++ b/src/quote/spanned.rs.html @@ -1,7 +1,7 @@ -spanned.rs - source +spanned.rs - source -
 1
+
 1
  2
  3
  4
@@ -87,4 +87,5 @@
         .unwrap_or(first)
 }
 

-

\ No newline at end of file
+
+ \ No newline at end of file diff --git a/src/quote/to_tokens.rs.html b/src/quote/to_tokens.rs.html index 2150102..5488b54 100644 --- a/src/quote/to_tokens.rs.html +++ b/src/quote/to_tokens.rs.html @@ -1,7 +1,7 @@ -to_tokens.rs - source +to_tokens.rs - source -
  1
+
  1
   2
   3
   4
@@ -421,4 +421,5 @@
     }
 }
 

-

\ No newline at end of file
+
+ \ No newline at end of file diff --git a/src/syn/attr.rs.html b/src/syn/attr.rs.html index 6d4e1c8..739d0c3 100644 --- a/src/syn/attr.rs.html +++ b/src/syn/attr.rs.html @@ -1,7 +1,7 @@ -attr.rs - source +attr.rs - source -
  1
+
  1
   2
   3
   4
@@ -665,12 +665,6 @@
 662
 663
 664
-665
-666
-667
-668
-669
-670
 
 use super::*;
 use crate::punctuated::Punctuated;
@@ -924,9 +918,7 @@
     #[cfg_attr(doc_cfg, doc(cfg(feature = "parsing")))]
     pub fn parse_inner(input: ParseStream) -> Result<Vec<Self>> {
         let mut attrs = Vec::new();
-        while input.peek(Token![#]) && input.peek2(Token![!]) {
-            attrs.push(input.call(parsing::single_parse_inner)?);
-        }
+        parsing::parse_inner(input, &mut attrs)?;
         Ok(attrs)
     }
 }
@@ -1177,8 +1169,13 @@
     use super::*;
     use crate::ext::IdentExt;
     use crate::parse::{Parse, ParseStream, Result};
-    #[cfg(feature = "full")]
-    use crate::private;
+
+    pub fn parse_inner(input: ParseStream, attrs: &mut Vec<Attribute>) -> Result<()> {
+        while input.peek(Token![#]) && input.peek2(Token![!]) {
+            attrs.push(input.call(parsing::single_parse_inner)?);
+        }
+        Ok(())
+    }
 
     pub fn single_parse_inner(input: ParseStream) -> Result<Attribute> {
         let content;
@@ -1202,15 +1199,6 @@
         })
     }
 
-    #[cfg(feature = "full")]
-    impl private {
-        pub(crate) fn attrs(outer: Vec<Attribute>, inner: Vec<Attribute>) -> Vec<Attribute> {
-            let mut attrs = outer;
-            attrs.extend(inner);
-            attrs
-        }
-    }
-
     // Like Path::parse_mod_style but accepts keywords in the path.
     fn parse_meta_path(input: ParseStream) -> Result<Path> {
         Ok(Path {
@@ -1329,7 +1317,7 @@
             self.path.to_tokens(tokens);
             self.paren_token.surround(tokens, |tokens| {
                 self.nested.to_tokens(tokens);
-            })
+            });
         }
     }
 
@@ -1343,4 +1331,5 @@
     }
 }
 

-

\ No newline at end of file
+
+ \ No newline at end of file diff --git a/src/syn/await.rs.html b/src/syn/await.rs.html index 4aff35d..11673f5 100644 --- a/src/syn/await.rs.html +++ b/src/syn/await.rs.html @@ -1,10 +1,11 @@ -await.rs - source +await.rs - source -
1
+
1
 2
 
 // See include!("await.rs") in token.rs.
 export_token_macro! {[await]}
 

-

\ No newline at end of file
+
+ \ No newline at end of file diff --git a/src/syn/bigint.rs.html b/src/syn/bigint.rs.html index 713094a..3fe9b2e 100644 --- a/src/syn/bigint.rs.html +++ b/src/syn/bigint.rs.html @@ -1,7 +1,7 @@ -bigint.rs - source +bigint.rs - source -
 1
+
 1
  2
  3
  4
@@ -135,4 +135,5 @@
     }
 }
 

-

\ No newline at end of file
+
+ \ No newline at end of file diff --git a/src/syn/buffer.rs.html b/src/syn/buffer.rs.html index 67c8888..e2eaf0f 100644 --- a/src/syn/buffer.rs.html +++ b/src/syn/buffer.rs.html @@ -1,7 +1,7 @@ -buffer.rs - source +buffer.rs - source -
  1
+
  1
   2
   3
   4
@@ -801,4 +801,5 @@
     }
 }
 

-

\ No newline at end of file
+
+ \ No newline at end of file diff --git a/src/syn/custom_keyword.rs.html b/src/syn/custom_keyword.rs.html index 58be948..0d16c9f 100644 --- a/src/syn/custom_keyword.rs.html +++ b/src/syn/custom_keyword.rs.html @@ -1,7 +1,7 @@ -custom_keyword.rs - source +custom_keyword.rs - source -
  1
+
  1
   2
   3
   4
@@ -253,6 +253,7 @@
 250
 251
 252
+253
 
 /// Define a type that supports parsing and printing a given identifier as if it
 /// were a keyword.
@@ -454,6 +455,7 @@
     ($ident:ident) => {
         impl $crate::__private::Copy for $ident {}
 
+        #[allow(clippy::expl_impl_clone_on_copy)]
         impl $crate::__private::Clone for $ident {
             fn clone(&self) -> Self {
                 *self
@@ -507,4 +509,5 @@
     ($ident:ident) => {};
 }
 

-

\ No newline at end of file
+
+ \ No newline at end of file diff --git a/src/syn/custom_punctuation.rs.html b/src/syn/custom_punctuation.rs.html index 8b84e3b..d628182 100644 --- a/src/syn/custom_punctuation.rs.html +++ b/src/syn/custom_punctuation.rs.html @@ -1,7 +1,7 @@ -custom_punctuation.rs - source +custom_punctuation.rs - source -
  1
+
  1
   2
   3
   4
@@ -300,6 +300,7 @@
 297
 298
 299
+300
 
 /// Define a type that supports parsing and printing a multi-character symbol
 /// as if it were a punctuation token.
@@ -472,6 +473,7 @@
     ($ident:ident, $($tt:tt)+) => {
         impl $crate::__private::Copy for $ident {}
 
+        #[allow(clippy::expl_impl_clone_on_copy)]
         impl $crate::__private::Clone for $ident {
             fn clone(&self) -> Self {
                 *self
@@ -601,4 +603,5 @@
     };
 }
 

-

\ No newline at end of file
+
+ \ No newline at end of file diff --git a/src/syn/data.rs.html b/src/syn/data.rs.html index a24ef58..608f3d8 100644 --- a/src/syn/data.rs.html +++ b/src/syn/data.rs.html @@ -1,7 +1,7 @@ -data.rs - source +data.rs - source -
  1
+
  1
   2
   3
   4
@@ -491,6 +491,17 @@
 488
 489
 490
+491
+492
+493
+494
+495
+496
+497
+498
+499
+500
+501
 
 use super::*;
 use crate::punctuated::Punctuated;
@@ -740,29 +751,29 @@
     #[cfg_attr(doc_cfg, doc(cfg(feature = "parsing")))]
     impl Parse for Variant {
         fn parse(input: ParseStream) -> Result<Self> {
-            let attrs = input.call(Attribute::parse_outer)?;
+            let mut attrs = input.call(Attribute::parse_outer)?;
             let _visibility: Visibility = input.parse()?;
+            let ident: Ident = input.parse()?;
+            let fields = if input.peek(token::Brace) {
+                let fields = parse_braced(input, &mut attrs)?;
+                Fields::Named(fields)
+            } else if input.peek(token::Paren) {
+                Fields::Unnamed(input.parse()?)
+            } else {
+                Fields::Unit
+            };
+            let discriminant = if input.peek(Token![=]) {
+                let eq_token: Token![=] = input.parse()?;
+                let discriminant: Expr = input.parse()?;
+                Some((eq_token, discriminant))
+            } else {
+                None
+            };
             Ok(Variant {
                 attrs,
-                ident: input.parse()?,
-                fields: {
-                    if input.peek(token::Brace) {
-                        Fields::Named(input.parse()?)
-                    } else if input.peek(token::Paren) {
-                        Fields::Unnamed(input.parse()?)
-                    } else {
-                        Fields::Unit
-                    }
-                },
-                discriminant: {
-                    if input.peek(Token![=]) {
-                        let eq_token: Token![=] = input.parse()?;
-                        let discriminant: Expr = input.parse()?;
-                        Some((eq_token, discriminant))
-                    } else {
-                        None
-                    }
-                },
+                ident,
+                fields,
+                discriminant,
             })
         }
     }
@@ -789,6 +800,17 @@
         }
     }
 
+    pub(crate) fn parse_braced(
+        input: ParseStream,
+        attrs: &mut Vec<Attribute>,
+    ) -> Result<FieldsNamed> {
+        let content;
+        let brace_token = braced!(content in input);
+        attr::parsing::parse_inner(&content, attrs)?;
+        let named = content.parse_terminated(Field::parse_named)?;
+        Ok(FieldsNamed { brace_token, named })
+    }
+
     impl Field {
         /// Parses a named (braced struct) field.
         #[cfg_attr(doc_cfg, doc(cfg(feature = "parsing")))]
@@ -958,7 +980,7 @@
     #[cfg_attr(doc_cfg, doc(cfg(feature = "printing")))]
     impl ToTokens for VisPublic {
         fn to_tokens(&self, tokens: &mut TokenStream) {
-            self.pub_token.to_tokens(tokens)
+            self.pub_token.to_tokens(tokens);
         }
     }
 
@@ -983,4 +1005,5 @@
     }
 }
 

-

\ No newline at end of file
+
+ \ No newline at end of file diff --git a/src/syn/derive.rs.html b/src/syn/derive.rs.html index 47ab87a..9e5f4d4 100644 --- a/src/syn/derive.rs.html +++ b/src/syn/derive.rs.html @@ -1,7 +1,7 @@ -derive.rs - source +derive.rs - source -
  1
+
  1
   2
   3
   4
@@ -275,6 +275,12 @@
 272
 273
 274
+275
+276
+277
+278
+279
+280
 
 use super::*;
 use crate::punctuated::Punctuated;
@@ -373,7 +379,7 @@
     #[cfg_attr(doc_cfg, doc(cfg(feature = "parsing")))]
     impl Parse for DeriveInput {
         fn parse(input: ParseStream) -> Result<Self> {
-            let attrs = input.call(Attribute::parse_outer)?;
+            let mut attrs = input.call(Attribute::parse_outer)?;
             let vis = input.parse::<Visibility>()?;
 
             let lookahead = input.lookahead1();
@@ -381,7 +387,7 @@
                 let struct_token = input.parse::<Token![struct]>()?;
                 let ident = input.parse::<Ident>()?;
                 let generics = input.parse::<Generics>()?;
-                let (where_clause, fields, semi) = data_struct(input)?;
+                let (where_clause, fields, semi) = data_struct(input, &mut attrs)?;
                 Ok(DeriveInput {
                     attrs,
                     vis,
@@ -400,7 +406,7 @@
                 let enum_token = input.parse::<Token![enum]>()?;
                 let ident = input.parse::<Ident>()?;
                 let generics = input.parse::<Generics>()?;
-                let (where_clause, brace, variants) = data_enum(input)?;
+                let (where_clause, brace, variants) = data_enum(input, &mut attrs)?;
                 Ok(DeriveInput {
                     attrs,
                     vis,
@@ -419,7 +425,7 @@
                 let union_token = input.parse::<Token![union]>()?;
                 let ident = input.parse::<Ident>()?;
                 let generics = input.parse::<Generics>()?;
-                let (where_clause, fields) = data_union(input)?;
+                let (where_clause, fields) = data_union(input, &mut attrs)?;
                 Ok(DeriveInput {
                     attrs,
                     vis,
@@ -441,6 +447,7 @@
 
     pub fn data_struct(
         input: ParseStream,
+        attrs: &mut Vec<Attribute>,
     ) -> Result<(Option<WhereClause>, Fields, Option<Token![;]>)> {
         let mut lookahead = input.lookahead1();
         let mut where_clause = None;
@@ -465,7 +472,7 @@
                 Err(lookahead.error())
             }
         } else if lookahead.peek(token::Brace) {
-            let fields = input.parse()?;
+            let fields = data::parsing::parse_braced(input, attrs)?;
             Ok((where_clause, Fields::Named(fields), None))
         } else if lookahead.peek(Token![;]) {
             let semi = input.parse()?;
@@ -477,6 +484,7 @@
 
     pub fn data_enum(
         input: ParseStream,
+        attrs: &mut Vec<Attribute>,
     ) -> Result<(
         Option<WhereClause>,
         token::Brace,
@@ -486,14 +494,18 @@
 
         let content;
         let brace = braced!(content in input);
+        attr::parsing::parse_inner(&content, attrs)?;
         let variants = content.parse_terminated(Variant::parse)?;
 
         Ok((where_clause, brace, variants))
     }
 
-    pub fn data_union(input: ParseStream) -> Result<(Option<WhereClause>, FieldsNamed)> {
+    pub fn data_union(
+        input: ParseStream,
+        attrs: &mut Vec<Attribute>,
+    ) -> Result<(Option<WhereClause>, FieldsNamed)> {
         let where_clause = input.parse()?;
-        let fields = input.parse()?;
+        let fields = data::parsing::parse_braced(input, attrs)?;
         Ok((where_clause, fields))
     }
 }
@@ -551,4 +563,5 @@
     }
 }
 

-

\ No newline at end of file
+
+ \ No newline at end of file diff --git a/src/syn/discouraged.rs.html b/src/syn/discouraged.rs.html index f12df73..c1e1299 100644 --- a/src/syn/discouraged.rs.html +++ b/src/syn/discouraged.rs.html @@ -1,7 +1,7 @@ -discouraged.rs - source +discouraged.rs - source -
  1
+
  1
   2
   3
   4
@@ -387,8 +387,9 @@
 
         // See comment on `cell` in the struct definition.
         self.cell
-            .set(unsafe { mem::transmute::<Cursor, Cursor<'static>>(fork.cursor()) })
+            .set(unsafe { mem::transmute::<Cursor, Cursor<'static>>(fork.cursor()) });
     }
 }
 

-

\ No newline at end of file
+
+ \ No newline at end of file diff --git a/src/syn/error.rs.html b/src/syn/error.rs.html index 48de96b..2974102 100644 --- a/src/syn/error.rs.html +++ b/src/syn/error.rs.html @@ -1,7 +1,7 @@ -error.rs - source +error.rs - source -
  1
+
  1
   2
   3
   4
@@ -652,7 +652,7 @@
     /// Add another error message to self such that when `to_compile_error()` is
     /// called, both errors will be emitted together.
     pub fn combine(&mut self, another: Error) {
-        self.messages.extend(another.messages)
+        self.messages.extend(another.messages);
     }
 }
 
@@ -765,7 +765,7 @@
 
 impl From<LexError> for Error {
     fn from(err: LexError) -> Self {
-        Error::new(Span::call_site(), format!("{:?}", err))
+        Error::new(err.span(), "lex error")
     }
 }
 
@@ -827,4 +827,5 @@
     }
 }
 

-

\ No newline at end of file
+
+ \ No newline at end of file diff --git a/src/syn/export.rs.html b/src/syn/export.rs.html index e2d57fb..43f44e9 100644 --- a/src/syn/export.rs.html +++ b/src/syn/export.rs.html @@ -1,7 +1,7 @@ -export.rs - source +export.rs - source -
 1
+
 1
  2
  3
  4
@@ -77,4 +77,5 @@
 
 pub struct private(pub(crate) ());
 

-

\ No newline at end of file
+
+ \ No newline at end of file diff --git a/src/syn/expr.rs.html b/src/syn/expr.rs.html index 7ef8b7b..af8d435 100644 --- a/src/syn/expr.rs.html +++ b/src/syn/expr.rs.html @@ -1,7 +1,7 @@ -expr.rs - source +expr.rs - source -
   1
+
   1
    2
    3
    4
@@ -3317,6 +3317,187 @@
 3314
 3315
 3316
+3317
+3318
+3319
+3320
+3321
+3322
+3323
+3324
+3325
+3326
+3327
+3328
+3329
+3330
+3331
+3332
+3333
+3334
+3335
+3336
+3337
+3338
+3339
+3340
+3341
+3342
+3343
+3344
+3345
+3346
+3347
+3348
+3349
+3350
+3351
+3352
+3353
+3354
+3355
+3356
+3357
+3358
+3359
+3360
+3361
+3362
+3363
+3364
+3365
+3366
+3367
+3368
+3369
+3370
+3371
+3372
+3373
+3374
+3375
+3376
+3377
+3378
+3379
+3380
+3381
+3382
+3383
+3384
+3385
+3386
+3387
+3388
+3389
+3390
+3391
+3392
+3393
+3394
+3395
+3396
+3397
+3398
+3399
+3400
+3401
+3402
+3403
+3404
+3405
+3406
+3407
+3408
+3409
+3410
+3411
+3412
+3413
+3414
+3415
+3416
+3417
+3418
+3419
+3420
+3421
+3422
+3423
+3424
+3425
+3426
+3427
+3428
+3429
+3430
+3431
+3432
+3433
+3434
+3435
+3436
+3437
+3438
+3439
+3440
+3441
+3442
+3443
+3444
+3445
+3446
+3447
+3448
+3449
+3450
+3451
+3452
+3453
+3454
+3455
+3456
+3457
+3458
+3459
+3460
+3461
+3462
+3463
+3464
+3465
+3466
+3467
+3468
+3469
+3470
+3471
+3472
+3473
+3474
+3475
+3476
+3477
+3478
+3479
+3480
+3481
+3482
+3483
+3484
+3485
+3486
+3487
+3488
+3489
+3490
+3491
+3492
+3493
+3494
+3495
+3496
+3497
 
 use super::*;
 use crate::punctuated::Punctuated;
@@ -4171,6 +4352,24 @@
     }
 }
 
+impl From<Ident> for Member {
+    fn from(ident: Ident) -> Member {
+        Member::Named(ident)
+    }
+}
+
+impl From<Index> for Member {
+    fn from(index: Index) -> Member {
+        Member::Unnamed(index)
+    }
+}
+
+impl From<usize> for Member {
+    fn from(index: usize) -> Member {
+        Member::Unnamed(Index::from(index))
+    }
+}
+
 impl Eq for Member {}
 
 impl PartialEq for Member {
@@ -4642,6 +4841,7 @@
                 let rhs = if input.is_empty()
                     || input.peek(Token![,])
                     || input.peek(Token![;])
+                    || input.peek(Token![.]) && !input.peek(Token![..])
                     || !allow_struct.0 && input.peek(token::Brace)
                 {
                     None
@@ -4742,7 +4942,9 @@
             Precedence::Assign
         } else if input.peek(Token![..]) {
             Precedence::Range
-        } else if input.peek(Token![as]) || input.peek(Token![:]) && !input.peek(Token![::]) {
+        } else if input.peek(Token![as])
+            || cfg!(feature = "full") && input.peek(Token![:]) && !input.peek(Token![::])
+        {
             Precedence::Cast
         } else {
             Precedence::Any
@@ -4812,17 +5014,9 @@
                 }))
             }
         } else if input.peek(Token![box]) {
-            Ok(Expr::Box(ExprBox {
-                attrs,
-                box_token: input.parse()?,
-                expr: Box::new(unary_expr(input, allow_struct)?),
-            }))
+            expr_box(input, attrs, allow_struct).map(Expr::Box)
         } else if input.peek(Token![*]) || input.peek(Token![!]) || input.peek(Token![-]) {
-            Ok(Expr::Unary(ExprUnary {
-                attrs,
-                op: input.parse()?,
-                expr: Box::new(unary_expr(input, allow_struct)?),
-            }))
+            expr_unary(input, attrs, allow_struct).map(Expr::Unary)
         } else {
             trailer_expr(attrs, input, allow_struct)
         }
@@ -4849,7 +5043,7 @@
     // <atom> ? ...
     #[cfg(feature = "full")]
     fn trailer_expr(
-        outer_attrs: Vec<Attribute>,
+        mut attrs: Vec<Attribute>,
         input: ParseStream,
         allow_struct: AllowStruct,
     ) -> Result<Expr> {
@@ -4857,7 +5051,7 @@
         let mut e = trailer_helper(input, atom)?;
 
         let inner_attrs = e.replace_attrs(Vec::new());
-        let attrs = private::attrs(outer_attrs, inner_attrs);
+        attrs.extend(inner_attrs);
         e.replace_attrs(attrs);
         Ok(e)
     }
@@ -4873,7 +5067,13 @@
                     paren_token: parenthesized!(content in input),
                     args: content.parse_terminated(Expr::parse)?,
                 });
-            } else if input.peek(Token![.]) && !input.peek(Token![..]) {
+            } else if input.peek(Token![.])
+                && !input.peek(Token![..])
+                && match e {
+                    Expr::Range(_) => false,
+                    _ => true,
+                }
+            {
                 let mut dot_token: Token![.] = input.parse()?;
 
                 let await_token: Option<token::Await> = input.parse()?;
@@ -5023,9 +5223,9 @@
         } else if input.peek(Token![async])
             && (input.peek2(token::Brace) || input.peek2(Token![move]) && input.peek3(token::Brace))
         {
-            input.call(expr_async).map(Expr::Async)
+            input.parse().map(Expr::Async)
         } else if input.peek(Token![try]) && input.peek2(token::Brace) {
-            input.call(expr_try_block).map(Expr::TryBlock)
+            input.parse().map(Expr::TryBlock)
         } else if input.peek(Token![|])
             || input.peek(Token![async]) && (input.peek2(Token![|]) || input.peek2(Token![move]))
             || input.peek(Token![static])
@@ -5046,13 +5246,13 @@
         } else if input.peek(Token![break]) {
             expr_break(input, allow_struct).map(Expr::Break)
         } else if input.peek(Token![continue]) {
-            input.call(expr_continue).map(Expr::Continue)
+            input.parse().map(Expr::Continue)
         } else if input.peek(Token![return]) {
             expr_ret(input, allow_struct).map(Expr::Return)
         } else if input.peek(token::Bracket) {
             array_or_repeat(input)
         } else if input.peek(Token![let]) {
-            input.call(expr_let).map(Expr::Let)
+            input.parse().map(Expr::Let)
         } else if input.peek(Token![if]) {
             input.parse().map(Expr::If)
         } else if input.peek(Token![while]) {
@@ -5064,13 +5264,13 @@
         } else if input.peek(Token![match]) {
             input.parse().map(Expr::Match)
         } else if input.peek(Token![yield]) {
-            input.call(expr_yield).map(Expr::Yield)
+            input.parse().map(Expr::Yield)
         } else if input.peek(Token![unsafe]) {
-            input.call(expr_unsafe).map(Expr::Unsafe)
+            input.parse().map(Expr::Unsafe)
         } else if input.peek(Token![const]) {
             input.call(expr_const).map(Expr::Verbatim)
         } else if input.peek(token::Brace) {
-            input.call(expr_block).map(Expr::Block)
+            input.parse().map(Expr::Block)
         } else if input.peek(Token![..]) {
             expr_range(input, allow_struct).map(Expr::Range)
         } else if input.peek(Token![_]) {
@@ -5086,7 +5286,7 @@
             } else if input.peek(Token![loop]) {
                 Expr::Loop(input.parse()?)
             } else if input.peek(token::Brace) {
-                Expr::Block(input.call(expr_block)?)
+                Expr::Block(input.parse()?)
             } else {
                 return Err(input.error("expected loop or block expression"));
             };
@@ -5164,6 +5364,17 @@
         }
     }
 
+    #[cfg(feature = "full")]
+    #[cfg_attr(doc_cfg, doc(cfg(feature = "parsing")))]
+    impl Parse for ExprMacro {
+        fn parse(input: ParseStream) -> Result<Self> {
+            Ok(ExprMacro {
+                attrs: Vec::new(),
+                mac: input.parse()?,
+            })
+        }
+    }
+
     #[cfg(feature = "full")]
     fn paren_or_tuple(input: ParseStream) -> Result<Expr> {
         let content;
@@ -5250,6 +5461,48 @@
         }
     }
 
+    #[cfg(feature = "full")]
+    #[cfg_attr(doc_cfg, doc(cfg(feature = "parsing")))]
+    impl Parse for ExprArray {
+        fn parse(input: ParseStream) -> Result<Self> {
+            let content;
+            let bracket_token = bracketed!(content in input);
+            let inner_attrs = content.call(Attribute::parse_inner)?;
+            let mut elems = Punctuated::new();
+
+            while !content.is_empty() {
+                let first: Expr = content.parse()?;
+                elems.push_value(first);
+                if content.is_empty() {
+                    break;
+                }
+                let punct = content.parse()?;
+                elems.push_punct(punct);
+            }
+
+            Ok(ExprArray {
+                attrs: inner_attrs,
+                bracket_token,
+                elems,
+            })
+        }
+    }
+
+    #[cfg(feature = "full")]
+    #[cfg_attr(doc_cfg, doc(cfg(feature = "parsing")))]
+    impl Parse for ExprRepeat {
+        fn parse(input: ParseStream) -> Result<Self> {
+            let content;
+            Ok(ExprRepeat {
+                bracket_token: bracketed!(content in input),
+                attrs: content.call(Attribute::parse_inner)?,
+                expr: content.parse()?,
+                semi_token: content.parse()?,
+                len: content.parse()?,
+            })
+        }
+    }
+
     #[cfg(feature = "full")]
     pub(crate) fn expr_early(input: ParseStream) -> Result<Expr> {
         let mut attrs = input.call(expr_attrs)?;
@@ -5264,13 +5517,13 @@
         } else if input.peek(Token![match]) {
             Expr::Match(input.parse()?)
         } else if input.peek(Token![try]) && input.peek2(token::Brace) {
-            Expr::TryBlock(input.call(expr_try_block)?)
+            Expr::TryBlock(input.parse()?)
         } else if input.peek(Token![unsafe]) {
-            Expr::Unsafe(input.call(expr_unsafe)?)
+            Expr::Unsafe(input.parse()?)
         } else if input.peek(Token![const]) {
             Expr::Verbatim(input.call(expr_const)?)
         } else if input.peek(token::Brace) {
-            Expr::Block(input.call(expr_block)?)
+            Expr::Block(input.parse()?)
         } else {
             let allow_struct = AllowStruct(true);
             let mut expr = unary_expr(input, allow_struct)?;
@@ -5316,7 +5569,14 @@
         })
     }
 
-    #[cfg(not(feature = "full"))]
+    #[cfg(feature = "full")]
+    #[cfg_attr(doc_cfg, doc(cfg(feature = "parsing")))]
+    impl Parse for ExprParen {
+        fn parse(input: ParseStream) -> Result<Self> {
+            expr_paren(input)
+        }
+    }
+
     fn expr_paren(input: ParseStream) -> Result<ExprParen> {
         let content;
         Ok(ExprParen {
@@ -5334,7 +5594,7 @@
         }
 
         if input.peek(token::Brace) {
-            let block = input.call(expr::parsing::expr_block)?;
+            let block: ExprBlock = input.parse()?;
             return Ok(GenericMethodArgument::Const(Expr::Block(block)));
         }
 
@@ -5342,14 +5602,17 @@
     }
 
     #[cfg(feature = "full")]
-    fn expr_let(input: ParseStream) -> Result<ExprLet> {
-        Ok(ExprLet {
-            attrs: Vec::new(),
-            let_token: input.parse()?,
-            pat: pat::parsing::multi_pat_with_leading_vert(input)?,
-            eq_token: input.parse()?,
-            expr: Box::new(input.call(Expr::parse_without_eager_brace)?),
-        })
+    #[cfg_attr(doc_cfg, doc(cfg(feature = "parsing")))]
+    impl Parse for ExprLet {
+        fn parse(input: ParseStream) -> Result<Self> {
+            Ok(ExprLet {
+                attrs: Vec::new(),
+                let_token: input.parse()?,
+                pat: pat::parsing::multi_pat_with_leading_vert(input)?,
+                eq_token: input.parse()?,
+                expr: Box::new(input.call(Expr::parse_without_eager_brace)?),
+            })
+        }
     }
 
     #[cfg(feature = "full")]
@@ -5397,7 +5660,7 @@
     #[cfg_attr(doc_cfg, doc(cfg(feature = "parsing")))]
     impl Parse for ExprForLoop {
         fn parse(input: ParseStream) -> Result<Self> {
-            let outer_attrs = input.call(Attribute::parse_outer)?;
+            let mut attrs = input.call(Attribute::parse_outer)?;
             let label: Option<Label> = input.parse()?;
             let for_token: Token![for] = input.parse()?;
 
@@ -5408,11 +5671,11 @@
 
             let content;
             let brace_token = braced!(content in input);
-            let inner_attrs = content.call(Attribute::parse_inner)?;
+            attr::parsing::parse_inner(&content, &mut attrs)?;
             let stmts = content.call(Block::parse_within)?;
 
             Ok(ExprForLoop {
-                attrs: private::attrs(outer_attrs, inner_attrs),
+                attrs,
                 label,
                 for_token,
                 pat,
@@ -5427,17 +5690,17 @@
     #[cfg_attr(doc_cfg, doc(cfg(feature = "parsing")))]
     impl Parse for ExprLoop {
         fn parse(input: ParseStream) -> Result<Self> {
-            let outer_attrs = input.call(Attribute::parse_outer)?;
+            let mut attrs = input.call(Attribute::parse_outer)?;
             let label: Option<Label> = input.parse()?;
             let loop_token: Token![loop] = input.parse()?;
 
             let content;
             let brace_token = braced!(content in input);
-            let inner_attrs = content.call(Attribute::parse_inner)?;
+            attr::parsing::parse_inner(&content, &mut attrs)?;
             let stmts = content.call(Block::parse_within)?;
 
             Ok(ExprLoop {
-                attrs: private::attrs(outer_attrs, inner_attrs),
+                attrs,
                 label,
                 loop_token,
                 body: Block { brace_token, stmts },
@@ -5449,13 +5712,13 @@
     #[cfg_attr(doc_cfg, doc(cfg(feature = "parsing")))]
     impl Parse for ExprMatch {
         fn parse(input: ParseStream) -> Result<Self> {
-            let outer_attrs = input.call(Attribute::parse_outer)?;
+            let mut attrs = input.call(Attribute::parse_outer)?;
             let match_token: Token![match] = input.parse()?;
             let expr = Expr::parse_without_eager_brace(input)?;
 
             let content;
             let brace_token = braced!(content in input);
-            let inner_attrs = content.call(Attribute::parse_inner)?;
+            attr::parsing::parse_inner(&content, &mut attrs)?;
 
             let mut arms = Vec::new();
             while !content.is_empty() {
@@ -5463,7 +5726,7 @@
             }
 
             Ok(ExprMatch {
-                attrs: private::attrs(outer_attrs, inner_attrs),
+                attrs,
                 match_token,
                 expr: Box::new(expr),
                 brace_token,
@@ -5498,62 +5761,138 @@
     }
 
     impl_by_parsing_expr! {
-        ExprBox, Box, "expected box expression",
-        ExprArray, Array, "expected slice literal expression",
         ExprCall, Call, "expected function call expression",
         ExprMethodCall, MethodCall, "expected method call expression",
         ExprTuple, Tuple, "expected tuple expression",
         ExprBinary, Binary, "expected binary operation",
-        ExprUnary, Unary, "expected unary operation",
         ExprCast, Cast, "expected cast expression",
         ExprType, Type, "expected type ascription expression",
-        ExprLet, Let, "expected let guard",
-        ExprClosure, Closure, "expected closure expression",
-        ExprUnsafe, Unsafe, "expected unsafe block",
-        ExprBlock, Block, "expected blocked scope",
         ExprAssign, Assign, "expected assignment expression",
         ExprAssignOp, AssignOp, "expected compound assignment expression",
         ExprField, Field, "expected struct field access",
         ExprIndex, Index, "expected indexing expression",
         ExprRange, Range, "expected range expression",
-        ExprReference, Reference, "expected referencing operation",
-        ExprBreak, Break, "expected break expression",
-        ExprContinue, Continue, "expected continue expression",
-        ExprReturn, Return, "expected return expression",
-        ExprMacro, Macro, "expected macro invocation expression",
-        ExprStruct, Struct, "expected struct literal expression",
-        ExprRepeat, Repeat, "expected array literal constructed from one repeated element",
-        ExprParen, Paren, "expected parenthesized expression",
         ExprTry, Try, "expected try expression",
-        ExprAsync, Async, "expected async block",
-        ExprTryBlock, TryBlock, "expected try block",
-        ExprYield, Yield, "expected yield expression",
     }
 
     #[cfg(feature = "full")]
-    fn expr_try_block(input: ParseStream) -> Result<ExprTryBlock> {
-        Ok(ExprTryBlock {
-            attrs: Vec::new(),
-            try_token: input.parse()?,
-            block: input.parse()?,
+    #[cfg_attr(doc_cfg, doc(cfg(feature = "parsing")))]
+    impl Parse for ExprBox {
+        fn parse(input: ParseStream) -> Result<Self> {
+            let attrs = Vec::new();
+            let allow_struct = AllowStruct(true);
+            expr_box(input, attrs, allow_struct)
+        }
+    }
+
+    #[cfg(feature = "full")]
+    fn expr_box(
+        input: ParseStream,
+        attrs: Vec<Attribute>,
+        allow_struct: AllowStruct,
+    ) -> Result<ExprBox> {
+        Ok(ExprBox {
+            attrs,
+            box_token: input.parse()?,
+            expr: Box::new(unary_expr(input, allow_struct)?),
         })
     }
 
     #[cfg(feature = "full")]
-    fn expr_yield(input: ParseStream) -> Result<ExprYield> {
-        Ok(ExprYield {
-            attrs: Vec::new(),
-            yield_token: input.parse()?,
-            expr: {
-                if !input.is_empty() && !input.peek(Token![,]) && !input.peek(Token![;]) {
-                    Some(input.parse()?)
-                } else {
-                    None
-                }
-            },
+    #[cfg_attr(doc_cfg, doc(cfg(feature = "parsing")))]
+    impl Parse for ExprUnary {
+        fn parse(input: ParseStream) -> Result<Self> {
+            let attrs = Vec::new();
+            let allow_struct = AllowStruct(true);
+            expr_unary(input, attrs, allow_struct)
+        }
+    }
+
+    #[cfg(feature = "full")]
+    fn expr_unary(
+        input: ParseStream,
+        attrs: Vec<Attribute>,
+        allow_struct: AllowStruct,
+    ) -> Result<ExprUnary> {
+        Ok(ExprUnary {
+            attrs,
+            op: input.parse()?,
+            expr: Box::new(unary_expr(input, allow_struct)?),
         })
     }
 
+    #[cfg(feature = "full")]
+    #[cfg_attr(doc_cfg, doc(cfg(feature = "parsing")))]
+    impl Parse for ExprClosure {
+        fn parse(input: ParseStream) -> Result<Self> {
+            let allow_struct = AllowStruct(true);
+            expr_closure(input, allow_struct)
+        }
+    }
+
+    #[cfg(feature = "full")]
+    #[cfg_attr(doc_cfg, doc(cfg(feature = "parsing")))]
+    impl Parse for ExprReference {
+        fn parse(input: ParseStream) -> Result<Self> {
+            let allow_struct = AllowStruct(true);
+            Ok(ExprReference {
+                attrs: Vec::new(),
+                and_token: input.parse()?,
+                raw: Reserved::default(),
+                mutability: input.parse()?,
+                expr: Box::new(unary_expr(input, allow_struct)?),
+            })
+        }
+    }
+
+    #[cfg(feature = "full")]
+    #[cfg_attr(doc_cfg, doc(cfg(feature = "parsing")))]
+    impl Parse for ExprBreak {
+        fn parse(input: ParseStream) -> Result<Self> {
+            let allow_struct = AllowStruct(true);
+            expr_break(input, allow_struct)
+        }
+    }
+
+    #[cfg(feature = "full")]
+    #[cfg_attr(doc_cfg, doc(cfg(feature = "parsing")))]
+    impl Parse for ExprReturn {
+        fn parse(input: ParseStream) -> Result<Self> {
+            let allow_struct = AllowStruct(true);
+            expr_ret(input, allow_struct)
+        }
+    }
+
+    #[cfg(feature = "full")]
+    #[cfg_attr(doc_cfg, doc(cfg(feature = "parsing")))]
+    impl Parse for ExprTryBlock {
+        fn parse(input: ParseStream) -> Result<Self> {
+            Ok(ExprTryBlock {
+                attrs: Vec::new(),
+                try_token: input.parse()?,
+                block: input.parse()?,
+            })
+        }
+    }
+
+    #[cfg(feature = "full")]
+    #[cfg_attr(doc_cfg, doc(cfg(feature = "parsing")))]
+    impl Parse for ExprYield {
+        fn parse(input: ParseStream) -> Result<Self> {
+            Ok(ExprYield {
+                attrs: Vec::new(),
+                yield_token: input.parse()?,
+                expr: {
+                    if !input.is_empty() && !input.peek(Token![,]) && !input.peek(Token![;]) {
+                        Some(input.parse()?)
+                    } else {
+                        None
+                    }
+                },
+            })
+        }
+    }
+
     #[cfg(feature = "full")]
     fn expr_closure(input: ParseStream, allow_struct: AllowStruct) -> Result<ExprClosure> {
         let asyncness: Option<Token![async]> = input.parse()?;
@@ -5611,13 +5950,16 @@
     }
 
     #[cfg(feature = "full")]
-    fn expr_async(input: ParseStream) -> Result<ExprAsync> {
-        Ok(ExprAsync {
-            attrs: Vec::new(),
-            async_token: input.parse()?,
-            capture: input.parse()?,
-            block: input.parse()?,
-        })
+    #[cfg_attr(doc_cfg, doc(cfg(feature = "parsing")))]
+    impl Parse for ExprAsync {
+        fn parse(input: ParseStream) -> Result<Self> {
+            Ok(ExprAsync {
+                attrs: Vec::new(),
+                async_token: input.parse()?,
+                capture: input.parse()?,
+                block: input.parse()?,
+            })
+        }
     }
 
     #[cfg(feature = "full")]
@@ -5664,18 +6006,18 @@
     #[cfg_attr(doc_cfg, doc(cfg(feature = "parsing")))]
     impl Parse for ExprWhile {
         fn parse(input: ParseStream) -> Result<Self> {
-            let outer_attrs = input.call(Attribute::parse_outer)?;
+            let mut attrs = input.call(Attribute::parse_outer)?;
             let label: Option<Label> = input.parse()?;
             let while_token: Token![while] = input.parse()?;
             let cond = Expr::parse_without_eager_brace(input)?;
 
             let content;
             let brace_token = braced!(content in input);
-            let inner_attrs = content.call(Attribute::parse_inner)?;
+            attr::parsing::parse_inner(&content, &mut attrs)?;
             let stmts = content.call(Block::parse_within)?;
 
             Ok(ExprWhile {
-                attrs: private::attrs(outer_attrs, inner_attrs),
+                attrs,
                 label,
                 while_token,
                 cond: Box::new(cond),
@@ -5708,12 +6050,15 @@
     }
 
     #[cfg(feature = "full")]
-    fn expr_continue(input: ParseStream) -> Result<ExprContinue> {
-        Ok(ExprContinue {
-            attrs: Vec::new(),
-            continue_token: input.parse()?,
-            label: input.parse()?,
-        })
+    #[cfg_attr(doc_cfg, doc(cfg(feature = "parsing")))]
+    impl Parse for ExprContinue {
+        fn parse(input: ParseStream) -> Result<Self> {
+            Ok(ExprContinue {
+                attrs: Vec::new(),
+                continue_token: input.parse()?,
+                label: input.parse()?,
+            })
+        }
     }
 
     #[cfg(feature = "full")]
@@ -5788,16 +6133,25 @@
         }
     }
 
+    #[cfg(feature = "full")]
+    #[cfg_attr(doc_cfg, doc(cfg(feature = "parsing")))]
+    impl Parse for ExprStruct {
+        fn parse(input: ParseStream) -> Result<Self> {
+            let attrs = Vec::new();
+            let path: Path = input.parse()?;
+            expr_struct_helper(input, attrs, path)
+        }
+    }
+
     #[cfg(feature = "full")]
     fn expr_struct_helper(
         input: ParseStream,
-        outer_attrs: Vec<Attribute>,
+        mut attrs: Vec<Attribute>,
         path: Path,
     ) -> Result<ExprStruct> {
         let content;
         let brace_token = braced!(content in input);
-        let inner_attrs = content.call(Attribute::parse_inner)?;
-        let attrs = private::attrs(outer_attrs, inner_attrs);
+        attr::parsing::parse_inner(&content, &mut attrs)?;
 
         let mut fields = Punctuated::new();
         while !content.is_empty() {
@@ -5835,19 +6189,22 @@
     }
 
     #[cfg(feature = "full")]
-    fn expr_unsafe(input: ParseStream) -> Result<ExprUnsafe> {
-        let unsafe_token: Token![unsafe] = input.parse()?;
+    #[cfg_attr(doc_cfg, doc(cfg(feature = "parsing")))]
+    impl Parse for ExprUnsafe {
+        fn parse(input: ParseStream) -> Result<Self> {
+            let unsafe_token: Token![unsafe] = input.parse()?;
 
-        let content;
-        let brace_token = braced!(content in input);
-        let inner_attrs = content.call(Attribute::parse_inner)?;
-        let stmts = content.call(Block::parse_within)?;
+            let content;
+            let brace_token = braced!(content in input);
+            let inner_attrs = content.call(Attribute::parse_inner)?;
+            let stmts = content.call(Block::parse_within)?;
 
-        Ok(ExprUnsafe {
-            attrs: inner_attrs,
-            unsafe_token,
-            block: Block { brace_token, stmts },
-        })
+            Ok(ExprUnsafe {
+                attrs: inner_attrs,
+                unsafe_token,
+                block: Block { brace_token, stmts },
+            })
+        }
     }
 
     #[cfg(feature = "full")]
@@ -5864,19 +6221,23 @@
     }
 
     #[cfg(feature = "full")]
-    pub fn expr_block(input: ParseStream) -> Result<ExprBlock> {
-        let label: Option<Label> = input.parse()?;
+    #[cfg_attr(doc_cfg, doc(cfg(feature = "parsing")))]
+    impl Parse for ExprBlock {
+        fn parse(input: ParseStream) -> Result<Self> {
+            let mut attrs = input.call(Attribute::parse_outer)?;
+            let label: Option<Label> = input.parse()?;
 
-        let content;
-        let brace_token = braced!(content in input);
-        let inner_attrs = content.call(Attribute::parse_inner)?;
-        let stmts = content.call(Block::parse_within)?;
+            let content;
+            let brace_token = braced!(content in input);
+            attr::parsing::parse_inner(&content, &mut attrs)?;
+            let stmts = content.call(Block::parse_within)?;
 
-        Ok(ExprBlock {
-            attrs: inner_attrs,
-            label,
-            block: Block { brace_token, stmts },
-        })
+            Ok(ExprBlock {
+                attrs,
+                label,
+                block: Block { brace_token, stmts },
+            })
+        }
     }
 
     #[cfg(feature = "full")]
@@ -5889,6 +6250,7 @@
                 if input.is_empty()
                     || input.peek(Token![,])
                     || input.peek(Token![;])
+                    || input.peek(Token![.]) && !input.peek(Token![..])
                     || !allow_struct.0 && input.peek(token::Brace)
                 {
                     None
@@ -6083,7 +6445,7 @@
             self.bracket_token.surround(tokens, |tokens| {
                 inner_attrs_to_tokens(&self.attrs, tokens);
                 self.elems.to_tokens(tokens);
-            })
+            });
         }
     }
 
@@ -6094,7 +6456,7 @@
             self.func.to_tokens(tokens);
             self.paren_token.surround(tokens, |tokens| {
                 self.args.to_tokens(tokens);
-            })
+            });
         }
     }
 
@@ -6148,7 +6510,7 @@
                 if self.elems.len() == 1 && !self.elems.trailing_punct() {
                     <Token![,]>::default().to_tokens(tokens);
                 }
-            })
+            });
         }
     }
 
@@ -6546,7 +6908,7 @@
                     Token![..](Span::call_site()).to_tokens(tokens);
                 }
                 self.rest.to_tokens(tokens);
-            })
+            });
         }
     }
 
@@ -6560,7 +6922,7 @@
                 self.expr.to_tokens(tokens);
                 self.semi_token.to_tokens(tokens);
                 self.len.to_tokens(tokens);
-            })
+            });
         }
     }
 
@@ -6635,4 +6997,5 @@
     }
 }
 

-

\ No newline at end of file
+
+ \ No newline at end of file diff --git a/src/syn/ext.rs.html b/src/syn/ext.rs.html index b547ffc..37046ac 100644 --- a/src/syn/ext.rs.html +++ b/src/syn/ext.rs.html @@ -1,7 +1,7 @@ -ext.rs - source +ext.rs - source -
  1
+
  1
   2
   3
   4
@@ -281,4 +281,5 @@
     }
 }
 

-

\ No newline at end of file
+
+ \ No newline at end of file diff --git a/src/syn/gen/clone.rs.html b/src/syn/gen/clone.rs.html index 07118d7..b3336ae 100644 --- a/src/syn/gen/clone.rs.html +++ b/src/syn/gen/clone.rs.html @@ -1,7 +1,7 @@ -clone.rs - source +clone.rs - source -
   1
+
   1
    2
    3
    4
@@ -4471,4 +4471,5 @@
     }
 }
 

-

\ No newline at end of file
+
+ \ No newline at end of file diff --git a/src/syn/gen/debug.rs.html b/src/syn/gen/debug.rs.html index ceed5eb..d8a73bc 100644 --- a/src/syn/gen/debug.rs.html +++ b/src/syn/gen/debug.rs.html @@ -1,7 +1,7 @@ -debug.rs - source +debug.rs - source -
   1
+
   1
    2
    3
    4
@@ -6073,4 +6073,5 @@
     }
 }
 

-

\ No newline at end of file
+
+ \ No newline at end of file diff --git a/src/syn/gen/eq.rs.html b/src/syn/gen/eq.rs.html index 8aa2a64..fd7fe1c 100644 --- a/src/syn/gen/eq.rs.html +++ b/src/syn/gen/eq.rs.html @@ -1,7 +1,7 @@ -eq.rs - source +eq.rs - source -
   1
+
   1
    2
    3
    4
@@ -4579,4 +4579,5 @@
     }
 }
 

-

\ No newline at end of file
+
+ \ No newline at end of file diff --git a/src/syn/gen/hash.rs.html b/src/syn/gen/hash.rs.html index 46761e1..b4b194a 100644 --- a/src/syn/gen/hash.rs.html +++ b/src/syn/gen/hash.rs.html @@ -1,7 +1,7 @@ -hash.rs - source +hash.rs - source -
   1
+
   1
    2
    3
    4
@@ -5737,4 +5737,5 @@
     }
 }
 

-

\ No newline at end of file
+
+ \ No newline at end of file diff --git a/src/syn/gen/up/gen_helper.rs.html b/src/syn/gen/up/gen_helper.rs.html index e4affb0..7d7896a 100644 --- a/src/syn/gen/up/gen_helper.rs.html +++ b/src/syn/gen/up/gen_helper.rs.html @@ -1,7 +1,7 @@ -gen_helper.rs - source +gen_helper.rs - source -
  1
+
  1
   2
   3
   4
@@ -311,4 +311,5 @@
     }
 }
 

-

\ No newline at end of file
+
+ \ No newline at end of file diff --git a/src/syn/gen/visit.rs.html b/src/syn/gen/visit.rs.html index cdc98c7..32404dc 100644 --- a/src/syn/gen/visit.rs.html +++ b/src/syn/gen/visit.rs.html @@ -1,7 +1,7 @@ -visit.rs - source +visit.rs - source -
   1
+
   1
    2
    3
    4
@@ -3812,740 +3812,740 @@
 pub trait Visit<'ast> {
     #[cfg(any(feature = "derive", feature = "full"))]
     fn visit_abi(&mut self, i: &'ast Abi) {
-        visit_abi(self, i)
+        visit_abi(self, i);
     }
     #[cfg(any(feature = "derive", feature = "full"))]
     fn visit_angle_bracketed_generic_arguments(&mut self, i: &'ast AngleBracketedGenericArguments) {
-        visit_angle_bracketed_generic_arguments(self, i)
+        visit_angle_bracketed_generic_arguments(self, i);
     }
     #[cfg(feature = "full")]
     fn visit_arm(&mut self, i: &'ast Arm) {
-        visit_arm(self, i)
+        visit_arm(self, i);
     }
     #[cfg(any(feature = "derive", feature = "full"))]
     fn visit_attr_style(&mut self, i: &'ast AttrStyle) {
-        visit_attr_style(self, i)
+        visit_attr_style(self, i);
     }
     #[cfg(any(feature = "derive", feature = "full"))]
     fn visit_attribute(&mut self, i: &'ast Attribute) {
-        visit_attribute(self, i)
+        visit_attribute(self, i);
     }
     #[cfg(any(feature = "derive", feature = "full"))]
     fn visit_bare_fn_arg(&mut self, i: &'ast BareFnArg) {
-        visit_bare_fn_arg(self, i)
+        visit_bare_fn_arg(self, i);
     }
     #[cfg(any(feature = "derive", feature = "full"))]
     fn visit_bin_op(&mut self, i: &'ast BinOp) {
-        visit_bin_op(self, i)
+        visit_bin_op(self, i);
     }
     #[cfg(any(feature = "derive", feature = "full"))]
     fn visit_binding(&mut self, i: &'ast Binding) {
-        visit_binding(self, i)
+        visit_binding(self, i);
     }
     #[cfg(feature = "full")]
     fn visit_block(&mut self, i: &'ast Block) {
-        visit_block(self, i)
+        visit_block(self, i);
     }
     #[cfg(any(feature = "derive", feature = "full"))]
     fn visit_bound_lifetimes(&mut self, i: &'ast BoundLifetimes) {
-        visit_bound_lifetimes(self, i)
+        visit_bound_lifetimes(self, i);
     }
     #[cfg(any(feature = "derive", feature = "full"))]
     fn visit_const_param(&mut self, i: &'ast ConstParam) {
-        visit_const_param(self, i)
+        visit_const_param(self, i);
     }
     #[cfg(any(feature = "derive", feature = "full"))]
     fn visit_constraint(&mut self, i: &'ast Constraint) {
-        visit_constraint(self, i)
+        visit_constraint(self, i);
     }
     #[cfg(feature = "derive")]
     fn visit_data(&mut self, i: &'ast Data) {
-        visit_data(self, i)
+        visit_data(self, i);
     }
     #[cfg(feature = "derive")]
     fn visit_data_enum(&mut self, i: &'ast DataEnum) {
-        visit_data_enum(self, i)
+        visit_data_enum(self, i);
     }
     #[cfg(feature = "derive")]
     fn visit_data_struct(&mut self, i: &'ast DataStruct) {
-        visit_data_struct(self, i)
+        visit_data_struct(self, i);
     }
     #[cfg(feature = "derive")]
     fn visit_data_union(&mut self, i: &'ast DataUnion) {
-        visit_data_union(self, i)
+        visit_data_union(self, i);
     }
     #[cfg(feature = "derive")]
     fn visit_derive_input(&mut self, i: &'ast DeriveInput) {
-        visit_derive_input(self, i)
+        visit_derive_input(self, i);
     }
     #[cfg(any(feature = "derive", feature = "full"))]
     fn visit_expr(&mut self, i: &'ast Expr) {
-        visit_expr(self, i)
+        visit_expr(self, i);
     }
     #[cfg(feature = "full")]
     fn visit_expr_array(&mut self, i: &'ast ExprArray) {
-        visit_expr_array(self, i)
+        visit_expr_array(self, i);
     }
     #[cfg(feature = "full")]
     fn visit_expr_assign(&mut self, i: &'ast ExprAssign) {
-        visit_expr_assign(self, i)
+        visit_expr_assign(self, i);
     }
     #[cfg(feature = "full")]
     fn visit_expr_assign_op(&mut self, i: &'ast ExprAssignOp) {
-        visit_expr_assign_op(self, i)
+        visit_expr_assign_op(self, i);
     }
     #[cfg(feature = "full")]
     fn visit_expr_async(&mut self, i: &'ast ExprAsync) {
-        visit_expr_async(self, i)
+        visit_expr_async(self, i);
     }
     #[cfg(feature = "full")]
     fn visit_expr_await(&mut self, i: &'ast ExprAwait) {
-        visit_expr_await(self, i)
+        visit_expr_await(self, i);
     }
     #[cfg(any(feature = "derive", feature = "full"))]
     fn visit_expr_binary(&mut self, i: &'ast ExprBinary) {
-        visit_expr_binary(self, i)
+        visit_expr_binary(self, i);
     }
     #[cfg(feature = "full")]
     fn visit_expr_block(&mut self, i: &'ast ExprBlock) {
-        visit_expr_block(self, i)
+        visit_expr_block(self, i);
     }
     #[cfg(feature = "full")]
     fn visit_expr_box(&mut self, i: &'ast ExprBox) {
-        visit_expr_box(self, i)
+        visit_expr_box(self, i);
     }
     #[cfg(feature = "full")]
     fn visit_expr_break(&mut self, i: &'ast ExprBreak) {
-        visit_expr_break(self, i)
+        visit_expr_break(self, i);
     }
     #[cfg(any(feature = "derive", feature = "full"))]
     fn visit_expr_call(&mut self, i: &'ast ExprCall) {
-        visit_expr_call(self, i)
+        visit_expr_call(self, i);
     }
     #[cfg(any(feature = "derive", feature = "full"))]
     fn visit_expr_cast(&mut self, i: &'ast ExprCast) {
-        visit_expr_cast(self, i)
+        visit_expr_cast(self, i);
     }
     #[cfg(feature = "full")]
     fn visit_expr_closure(&mut self, i: &'ast ExprClosure) {
-        visit_expr_closure(self, i)
+        visit_expr_closure(self, i);
     }
     #[cfg(feature = "full")]
     fn visit_expr_continue(&mut self, i: &'ast ExprContinue) {
-        visit_expr_continue(self, i)
+        visit_expr_continue(self, i);
     }
     #[cfg(any(feature = "derive", feature = "full"))]
     fn visit_expr_field(&mut self, i: &'ast ExprField) {
-        visit_expr_field(self, i)
+        visit_expr_field(self, i);
     }
     #[cfg(feature = "full")]
     fn visit_expr_for_loop(&mut self, i: &'ast ExprForLoop) {
-        visit_expr_for_loop(self, i)
+        visit_expr_for_loop(self, i);
     }
     #[cfg(feature = "full")]
     fn visit_expr_group(&mut self, i: &'ast ExprGroup) {
-        visit_expr_group(self, i)
+        visit_expr_group(self, i);
     }
     #[cfg(feature = "full")]
     fn visit_expr_if(&mut self, i: &'ast ExprIf) {
-        visit_expr_if(self, i)
+        visit_expr_if(self, i);
     }
     #[cfg(any(feature = "derive", feature = "full"))]
     fn visit_expr_index(&mut self, i: &'ast ExprIndex) {
-        visit_expr_index(self, i)
+        visit_expr_index(self, i);
     }
     #[cfg(feature = "full")]
     fn visit_expr_let(&mut self, i: &'ast ExprLet) {
-        visit_expr_let(self, i)
+        visit_expr_let(self, i);
     }
     #[cfg(any(feature = "derive", feature = "full"))]
     fn visit_expr_lit(&mut self, i: &'ast ExprLit) {
-        visit_expr_lit(self, i)
+        visit_expr_lit(self, i);
     }
     #[cfg(feature = "full")]
     fn visit_expr_loop(&mut self, i: &'ast ExprLoop) {
-        visit_expr_loop(self, i)
+        visit_expr_loop(self, i);
     }
     #[cfg(feature = "full")]
     fn visit_expr_macro(&mut self, i: &'ast ExprMacro) {
-        visit_expr_macro(self, i)
+        visit_expr_macro(self, i);
     }
     #[cfg(feature = "full")]
     fn visit_expr_match(&mut self, i: &'ast ExprMatch) {
-        visit_expr_match(self, i)
+        visit_expr_match(self, i);
     }
     #[cfg(feature = "full")]
     fn visit_expr_method_call(&mut self, i: &'ast ExprMethodCall) {
-        visit_expr_method_call(self, i)
+        visit_expr_method_call(self, i);
     }
     #[cfg(any(feature = "derive", feature = "full"))]
     fn visit_expr_paren(&mut self, i: &'ast ExprParen) {
-        visit_expr_paren(self, i)
+        visit_expr_paren(self, i);
     }
     #[cfg(any(feature = "derive", feature = "full"))]
     fn visit_expr_path(&mut self, i: &'ast ExprPath) {
-        visit_expr_path(self, i)
+        visit_expr_path(self, i);
     }
     #[cfg(feature = "full")]
     fn visit_expr_range(&mut self, i: &'ast ExprRange) {
-        visit_expr_range(self, i)
+        visit_expr_range(self, i);
     }
     #[cfg(feature = "full")]
     fn visit_expr_reference(&mut self, i: &'ast ExprReference) {
-        visit_expr_reference(self, i)
+        visit_expr_reference(self, i);
     }
     #[cfg(feature = "full")]
     fn visit_expr_repeat(&mut self, i: &'ast ExprRepeat) {
-        visit_expr_repeat(self, i)
+        visit_expr_repeat(self, i);
     }
     #[cfg(feature = "full")]
     fn visit_expr_return(&mut self, i: &'ast ExprReturn) {
-        visit_expr_return(self, i)
+        visit_expr_return(self, i);
     }
     #[cfg(feature = "full")]
     fn visit_expr_struct(&mut self, i: &'ast ExprStruct) {
-        visit_expr_struct(self, i)
+        visit_expr_struct(self, i);
     }
     #[cfg(feature = "full")]
     fn visit_expr_try(&mut self, i: &'ast ExprTry) {
-        visit_expr_try(self, i)
+        visit_expr_try(self, i);
     }
     #[cfg(feature = "full")]
     fn visit_expr_try_block(&mut self, i: &'ast ExprTryBlock) {
-        visit_expr_try_block(self, i)
+        visit_expr_try_block(self, i);
     }
     #[cfg(feature = "full")]
     fn visit_expr_tuple(&mut self, i: &'ast ExprTuple) {
-        visit_expr_tuple(self, i)
+        visit_expr_tuple(self, i);
     }
     #[cfg(feature = "full")]
     fn visit_expr_type(&mut self, i: &'ast ExprType) {
-        visit_expr_type(self, i)
+        visit_expr_type(self, i);
     }
     #[cfg(any(feature = "derive", feature = "full"))]
     fn visit_expr_unary(&mut self, i: &'ast ExprUnary) {
-        visit_expr_unary(self, i)
+        visit_expr_unary(self, i);
     }
     #[cfg(feature = "full")]
     fn visit_expr_unsafe(&mut self, i: &'ast ExprUnsafe) {
-        visit_expr_unsafe(self, i)
+        visit_expr_unsafe(self, i);
     }
     #[cfg(feature = "full")]
     fn visit_expr_while(&mut self, i: &'ast ExprWhile) {
-        visit_expr_while(self, i)
+        visit_expr_while(self, i);
     }
     #[cfg(feature = "full")]
     fn visit_expr_yield(&mut self, i: &'ast ExprYield) {
-        visit_expr_yield(self, i)
+        visit_expr_yield(self, i);
     }
     #[cfg(any(feature = "derive", feature = "full"))]
     fn visit_field(&mut self, i: &'ast Field) {
-        visit_field(self, i)
+        visit_field(self, i);
     }
     #[cfg(feature = "full")]
     fn visit_field_pat(&mut self, i: &'ast FieldPat) {
-        visit_field_pat(self, i)
+        visit_field_pat(self, i);
     }
     #[cfg(feature = "full")]
     fn visit_field_value(&mut self, i: &'ast FieldValue) {
-        visit_field_value(self, i)
+        visit_field_value(self, i);
     }
     #[cfg(any(feature = "derive", feature = "full"))]
     fn visit_fields(&mut self, i: &'ast Fields) {
-        visit_fields(self, i)
+        visit_fields(self, i);
     }
     #[cfg(any(feature = "derive", feature = "full"))]
     fn visit_fields_named(&mut self, i: &'ast FieldsNamed) {
-        visit_fields_named(self, i)
+        visit_fields_named(self, i);
     }
     #[cfg(any(feature = "derive", feature = "full"))]
     fn visit_fields_unnamed(&mut self, i: &'ast FieldsUnnamed) {
-        visit_fields_unnamed(self, i)
+        visit_fields_unnamed(self, i);
     }
     #[cfg(feature = "full")]
     fn visit_file(&mut self, i: &'ast File) {
-        visit_file(self, i)
+        visit_file(self, i);
     }
     #[cfg(feature = "full")]
     fn visit_fn_arg(&mut self, i: &'ast FnArg) {
-        visit_fn_arg(self, i)
+        visit_fn_arg(self, i);
     }
     #[cfg(feature = "full")]
     fn visit_foreign_item(&mut self, i: &'ast ForeignItem) {
-        visit_foreign_item(self, i)
+        visit_foreign_item(self, i);
     }
     #[cfg(feature = "full")]
     fn visit_foreign_item_fn(&mut self, i: &'ast ForeignItemFn) {
-        visit_foreign_item_fn(self, i)
+        visit_foreign_item_fn(self, i);
     }
     #[cfg(feature = "full")]
     fn visit_foreign_item_macro(&mut self, i: &'ast ForeignItemMacro) {
-        visit_foreign_item_macro(self, i)
+        visit_foreign_item_macro(self, i);
     }
     #[cfg(feature = "full")]
     fn visit_foreign_item_static(&mut self, i: &'ast ForeignItemStatic) {
-        visit_foreign_item_static(self, i)
+        visit_foreign_item_static(self, i);
     }
     #[cfg(feature = "full")]
     fn visit_foreign_item_type(&mut self, i: &'ast ForeignItemType) {
-        visit_foreign_item_type(self, i)
+        visit_foreign_item_type(self, i);
     }
     #[cfg(any(feature = "derive", feature = "full"))]
     fn visit_generic_argument(&mut self, i: &'ast GenericArgument) {
-        visit_generic_argument(self, i)
+        visit_generic_argument(self, i);
     }
     #[cfg(feature = "full")]
     fn visit_generic_method_argument(&mut self, i: &'ast GenericMethodArgument) {
-        visit_generic_method_argument(self, i)
+        visit_generic_method_argument(self, i);
     }
     #[cfg(any(feature = "derive", feature = "full"))]
     fn visit_generic_param(&mut self, i: &'ast GenericParam) {
-        visit_generic_param(self, i)
+        visit_generic_param(self, i);
     }
     #[cfg(any(feature = "derive", feature = "full"))]
     fn visit_generics(&mut self, i: &'ast Generics) {
-        visit_generics(self, i)
+        visit_generics(self, i);
     }
     fn visit_ident(&mut self, i: &'ast Ident) {
-        visit_ident(self, i)
+        visit_ident(self, i);
     }
     #[cfg(feature = "full")]
     fn visit_impl_item(&mut self, i: &'ast ImplItem) {
-        visit_impl_item(self, i)
+        visit_impl_item(self, i);
     }
     #[cfg(feature = "full")]
     fn visit_impl_item_const(&mut self, i: &'ast ImplItemConst) {
-        visit_impl_item_const(self, i)
+        visit_impl_item_const(self, i);
     }
     #[cfg(feature = "full")]
     fn visit_impl_item_macro(&mut self, i: &'ast ImplItemMacro) {
-        visit_impl_item_macro(self, i)
+        visit_impl_item_macro(self, i);
     }
     #[cfg(feature = "full")]
     fn visit_impl_item_method(&mut self, i: &'ast ImplItemMethod) {
-        visit_impl_item_method(self, i)
+        visit_impl_item_method(self, i);
     }
     #[cfg(feature = "full")]
     fn visit_impl_item_type(&mut self, i: &'ast ImplItemType) {
-        visit_impl_item_type(self, i)
+        visit_impl_item_type(self, i);
     }
     #[cfg(any(feature = "derive", feature = "full"))]
     fn visit_index(&mut self, i: &'ast Index) {
-        visit_index(self, i)
+        visit_index(self, i);
     }
     #[cfg(feature = "full")]
     fn visit_item(&mut self, i: &'ast Item) {
-        visit_item(self, i)
+        visit_item(self, i);
     }
     #[cfg(feature = "full")]
     fn visit_item_const(&mut self, i: &'ast ItemConst) {
-        visit_item_const(self, i)
+        visit_item_const(self, i);
     }
     #[cfg(feature = "full")]
     fn visit_item_enum(&mut self, i: &'ast ItemEnum) {
-        visit_item_enum(self, i)
+        visit_item_enum(self, i);
     }
     #[cfg(feature = "full")]
     fn visit_item_extern_crate(&mut self, i: &'ast ItemExternCrate) {
-        visit_item_extern_crate(self, i)
+        visit_item_extern_crate(self, i);
     }
     #[cfg(feature = "full")]
     fn visit_item_fn(&mut self, i: &'ast ItemFn) {
-        visit_item_fn(self, i)
+        visit_item_fn(self, i);
     }
     #[cfg(feature = "full")]
     fn visit_item_foreign_mod(&mut self, i: &'ast ItemForeignMod) {
-        visit_item_foreign_mod(self, i)
+        visit_item_foreign_mod(self, i);
     }
     #[cfg(feature = "full")]
     fn visit_item_impl(&mut self, i: &'ast ItemImpl) {
-        visit_item_impl(self, i)
+        visit_item_impl(self, i);
     }
     #[cfg(feature = "full")]
     fn visit_item_macro(&mut self, i: &'ast ItemMacro) {
-        visit_item_macro(self, i)
+        visit_item_macro(self, i);
     }
     #[cfg(feature = "full")]
     fn visit_item_macro2(&mut self, i: &'ast ItemMacro2) {
-        visit_item_macro2(self, i)
+        visit_item_macro2(self, i);
     }
     #[cfg(feature = "full")]
     fn visit_item_mod(&mut self, i: &'ast ItemMod) {
-        visit_item_mod(self, i)
+        visit_item_mod(self, i);
     }
     #[cfg(feature = "full")]
     fn visit_item_static(&mut self, i: &'ast ItemStatic) {
-        visit_item_static(self, i)
+        visit_item_static(self, i);
     }
     #[cfg(feature = "full")]
     fn visit_item_struct(&mut self, i: &'ast ItemStruct) {
-        visit_item_struct(self, i)
+        visit_item_struct(self, i);
     }
     #[cfg(feature = "full")]
     fn visit_item_trait(&mut self, i: &'ast ItemTrait) {
-        visit_item_trait(self, i)
+        visit_item_trait(self, i);
     }
     #[cfg(feature = "full")]
     fn visit_item_trait_alias(&mut self, i: &'ast ItemTraitAlias) {
-        visit_item_trait_alias(self, i)
+        visit_item_trait_alias(self, i);
     }
     #[cfg(feature = "full")]
     fn visit_item_type(&mut self, i: &'ast ItemType) {
-        visit_item_type(self, i)
+        visit_item_type(self, i);
     }
     #[cfg(feature = "full")]
     fn visit_item_union(&mut self, i: &'ast ItemUnion) {
-        visit_item_union(self, i)
+        visit_item_union(self, i);
     }
     #[cfg(feature = "full")]
     fn visit_item_use(&mut self, i: &'ast ItemUse) {
-        visit_item_use(self, i)
+        visit_item_use(self, i);
     }
     #[cfg(feature = "full")]
     fn visit_label(&mut self, i: &'ast Label) {
-        visit_label(self, i)
+        visit_label(self, i);
     }
     fn visit_lifetime(&mut self, i: &'ast Lifetime) {
-        visit_lifetime(self, i)
+        visit_lifetime(self, i);
     }
     #[cfg(any(feature = "derive", feature = "full"))]
     fn visit_lifetime_def(&mut self, i: &'ast LifetimeDef) {
-        visit_lifetime_def(self, i)
+        visit_lifetime_def(self, i);
     }
     fn visit_lit(&mut self, i: &'ast Lit) {
-        visit_lit(self, i)
+        visit_lit(self, i);
     }
     fn visit_lit_bool(&mut self, i: &'ast LitBool) {
-        visit_lit_bool(self, i)
+        visit_lit_bool(self, i);
     }
     fn visit_lit_byte(&mut self, i: &'ast LitByte) {
-        visit_lit_byte(self, i)
+        visit_lit_byte(self, i);
     }
     fn visit_lit_byte_str(&mut self, i: &'ast LitByteStr) {
-        visit_lit_byte_str(self, i)
+        visit_lit_byte_str(self, i);
     }
     fn visit_lit_char(&mut self, i: &'ast LitChar) {
-        visit_lit_char(self, i)
+        visit_lit_char(self, i);
     }
     fn visit_lit_float(&mut self, i: &'ast LitFloat) {
-        visit_lit_float(self, i)
+        visit_lit_float(self, i);
     }
     fn visit_lit_int(&mut self, i: &'ast LitInt) {
-        visit_lit_int(self, i)
+        visit_lit_int(self, i);
     }
     fn visit_lit_str(&mut self, i: &'ast LitStr) {
-        visit_lit_str(self, i)
+        visit_lit_str(self, i);
     }
     #[cfg(feature = "full")]
     fn visit_local(&mut self, i: &'ast Local) {
-        visit_local(self, i)
+        visit_local(self, i);
     }
     #[cfg(any(feature = "derive", feature = "full"))]
     fn visit_macro(&mut self, i: &'ast Macro) {
-        visit_macro(self, i)
+        visit_macro(self, i);
     }
     #[cfg(any(feature = "derive", feature = "full"))]
     fn visit_macro_delimiter(&mut self, i: &'ast MacroDelimiter) {
-        visit_macro_delimiter(self, i)
+        visit_macro_delimiter(self, i);
     }
     #[cfg(any(feature = "derive", feature = "full"))]
     fn visit_member(&mut self, i: &'ast Member) {
-        visit_member(self, i)
+        visit_member(self, i);
     }
     #[cfg(any(feature = "derive", feature = "full"))]
     fn visit_meta(&mut self, i: &'ast Meta) {
-        visit_meta(self, i)
+        visit_meta(self, i);
     }
     #[cfg(any(feature = "derive", feature = "full"))]
     fn visit_meta_list(&mut self, i: &'ast MetaList) {
-        visit_meta_list(self, i)
+        visit_meta_list(self, i);
     }
     #[cfg(any(feature = "derive", feature = "full"))]
     fn visit_meta_name_value(&mut self, i: &'ast MetaNameValue) {
-        visit_meta_name_value(self, i)
+        visit_meta_name_value(self, i);
     }
     #[cfg(feature = "full")]
     fn visit_method_turbofish(&mut self, i: &'ast MethodTurbofish) {
-        visit_method_turbofish(self, i)
+        visit_method_turbofish(self, i);
     }
     #[cfg(any(feature = "derive", feature = "full"))]
     fn visit_nested_meta(&mut self, i: &'ast NestedMeta) {
-        visit_nested_meta(self, i)
+        visit_nested_meta(self, i);
     }
     #[cfg(any(feature = "derive", feature = "full"))]
     fn visit_parenthesized_generic_arguments(&mut self, i: &'ast ParenthesizedGenericArguments) {
-        visit_parenthesized_generic_arguments(self, i)
+        visit_parenthesized_generic_arguments(self, i);
     }
     #[cfg(feature = "full")]
     fn visit_pat(&mut self, i: &'ast Pat) {
-        visit_pat(self, i)
+        visit_pat(self, i);
     }
     #[cfg(feature = "full")]
     fn visit_pat_box(&mut self, i: &'ast PatBox) {
-        visit_pat_box(self, i)
+        visit_pat_box(self, i);
     }
     #[cfg(feature = "full")]
     fn visit_pat_ident(&mut self, i: &'ast PatIdent) {
-        visit_pat_ident(self, i)
+        visit_pat_ident(self, i);
     }
     #[cfg(feature = "full")]
     fn visit_pat_lit(&mut self, i: &'ast PatLit) {
-        visit_pat_lit(self, i)
+        visit_pat_lit(self, i);
     }
     #[cfg(feature = "full")]
     fn visit_pat_macro(&mut self, i: &'ast PatMacro) {
-        visit_pat_macro(self, i)
+        visit_pat_macro(self, i);
     }
     #[cfg(feature = "full")]
     fn visit_pat_or(&mut self, i: &'ast PatOr) {
-        visit_pat_or(self, i)
+        visit_pat_or(self, i);
     }
     #[cfg(feature = "full")]
     fn visit_pat_path(&mut self, i: &'ast PatPath) {
-        visit_pat_path(self, i)
+        visit_pat_path(self, i);
     }
     #[cfg(feature = "full")]
     fn visit_pat_range(&mut self, i: &'ast PatRange) {
-        visit_pat_range(self, i)
+        visit_pat_range(self, i);
     }
     #[cfg(feature = "full")]
     fn visit_pat_reference(&mut self, i: &'ast PatReference) {
-        visit_pat_reference(self, i)
+        visit_pat_reference(self, i);
     }
     #[cfg(feature = "full")]
     fn visit_pat_rest(&mut self, i: &'ast PatRest) {
-        visit_pat_rest(self, i)
+        visit_pat_rest(self, i);
     }
     #[cfg(feature = "full")]
     fn visit_pat_slice(&mut self, i: &'ast PatSlice) {
-        visit_pat_slice(self, i)
+        visit_pat_slice(self, i);
     }
     #[cfg(feature = "full")]
     fn visit_pat_struct(&mut self, i: &'ast PatStruct) {
-        visit_pat_struct(self, i)
+        visit_pat_struct(self, i);
     }
     #[cfg(feature = "full")]
     fn visit_pat_tuple(&mut self, i: &'ast PatTuple) {
-        visit_pat_tuple(self, i)
+        visit_pat_tuple(self, i);
     }
     #[cfg(feature = "full")]
     fn visit_pat_tuple_struct(&mut self, i: &'ast PatTupleStruct) {
-        visit_pat_tuple_struct(self, i)
+        visit_pat_tuple_struct(self, i);
     }
     #[cfg(feature = "full")]
     fn visit_pat_type(&mut self, i: &'ast PatType) {
-        visit_pat_type(self, i)
+        visit_pat_type(self, i);
     }
     #[cfg(feature = "full")]
     fn visit_pat_wild(&mut self, i: &'ast PatWild) {
-        visit_pat_wild(self, i)
+        visit_pat_wild(self, i);
     }
     #[cfg(any(feature = "derive", feature = "full"))]
     fn visit_path(&mut self, i: &'ast Path) {
-        visit_path(self, i)
+        visit_path(self, i);
     }
     #[cfg(any(feature = "derive", feature = "full"))]
     fn visit_path_arguments(&mut self, i: &'ast PathArguments) {
-        visit_path_arguments(self, i)
+        visit_path_arguments(self, i);
     }
     #[cfg(any(feature = "derive", feature = "full"))]
     fn visit_path_segment(&mut self, i: &'ast PathSegment) {
-        visit_path_segment(self, i)
+        visit_path_segment(self, i);
     }
     #[cfg(any(feature = "derive", feature = "full"))]
     fn visit_predicate_eq(&mut self, i: &'ast PredicateEq) {
-        visit_predicate_eq(self, i)
+        visit_predicate_eq(self, i);
     }
     #[cfg(any(feature = "derive", feature = "full"))]
     fn visit_predicate_lifetime(&mut self, i: &'ast PredicateLifetime) {
-        visit_predicate_lifetime(self, i)
+        visit_predicate_lifetime(self, i);
     }
     #[cfg(any(feature = "derive", feature = "full"))]
     fn visit_predicate_type(&mut self, i: &'ast PredicateType) {
-        visit_predicate_type(self, i)
+        visit_predicate_type(self, i);
     }
     #[cfg(any(feature = "derive", feature = "full"))]
     fn visit_qself(&mut self, i: &'ast QSelf) {
-        visit_qself(self, i)
+        visit_qself(self, i);
     }
     #[cfg(feature = "full")]
     fn visit_range_limits(&mut self, i: &'ast RangeLimits) {
-        visit_range_limits(self, i)
+        visit_range_limits(self, i);
     }
     #[cfg(feature = "full")]
     fn visit_receiver(&mut self, i: &'ast Receiver) {
-        visit_receiver(self, i)
+        visit_receiver(self, i);
     }
     #[cfg(any(feature = "derive", feature = "full"))]
     fn visit_return_type(&mut self, i: &'ast ReturnType) {
-        visit_return_type(self, i)
+        visit_return_type(self, i);
     }
     #[cfg(feature = "full")]
     fn visit_signature(&mut self, i: &'ast Signature) {
-        visit_signature(self, i)
+        visit_signature(self, i);
     }
     fn visit_span(&mut self, i: &Span) {
-        visit_span(self, i)
+        visit_span(self, i);
     }
     #[cfg(feature = "full")]
     fn visit_stmt(&mut self, i: &'ast Stmt) {
-        visit_stmt(self, i)
+        visit_stmt(self, i);
     }
     #[cfg(any(feature = "derive", feature = "full"))]
     fn visit_trait_bound(&mut self, i: &'ast TraitBound) {
-        visit_trait_bound(self, i)
+        visit_trait_bound(self, i);
     }
     #[cfg(any(feature = "derive", feature = "full"))]
     fn visit_trait_bound_modifier(&mut self, i: &'ast TraitBoundModifier) {
-        visit_trait_bound_modifier(self, i)
+        visit_trait_bound_modifier(self, i);
     }
     #[cfg(feature = "full")]
     fn visit_trait_item(&mut self, i: &'ast TraitItem) {
-        visit_trait_item(self, i)
+        visit_trait_item(self, i);
     }
     #[cfg(feature = "full")]
     fn visit_trait_item_const(&mut self, i: &'ast TraitItemConst) {
-        visit_trait_item_const(self, i)
+        visit_trait_item_const(self, i);
     }
     #[cfg(feature = "full")]
     fn visit_trait_item_macro(&mut self, i: &'ast TraitItemMacro) {
-        visit_trait_item_macro(self, i)
+        visit_trait_item_macro(self, i);
     }
     #[cfg(feature = "full")]
     fn visit_trait_item_method(&mut self, i: &'ast TraitItemMethod) {
-        visit_trait_item_method(self, i)
+        visit_trait_item_method(self, i);
     }
     #[cfg(feature = "full")]
     fn visit_trait_item_type(&mut self, i: &'ast TraitItemType) {
-        visit_trait_item_type(self, i)
+        visit_trait_item_type(self, i);
     }
     #[cfg(any(feature = "derive", feature = "full"))]
     fn visit_type(&mut self, i: &'ast Type) {
-        visit_type(self, i)
+        visit_type(self, i);
     }
     #[cfg(any(feature = "derive", feature = "full"))]
     fn visit_type_array(&mut self, i: &'ast TypeArray) {
-        visit_type_array(self, i)
+        visit_type_array(self, i);
     }
     #[cfg(any(feature = "derive", feature = "full"))]
     fn visit_type_bare_fn(&mut self, i: &'ast TypeBareFn) {
-        visit_type_bare_fn(self, i)
+        visit_type_bare_fn(self, i);
     }
     #[cfg(any(feature = "derive", feature = "full"))]
     fn visit_type_group(&mut self, i: &'ast TypeGroup) {
-        visit_type_group(self, i)
+        visit_type_group(self, i);
     }
     #[cfg(any(feature = "derive", feature = "full"))]
     fn visit_type_impl_trait(&mut self, i: &'ast TypeImplTrait) {
-        visit_type_impl_trait(self, i)
+        visit_type_impl_trait(self, i);
     }
     #[cfg(any(feature = "derive", feature = "full"))]
     fn visit_type_infer(&mut self, i: &'ast TypeInfer) {
-        visit_type_infer(self, i)
+        visit_type_infer(self, i);
     }
     #[cfg(any(feature = "derive", feature = "full"))]
     fn visit_type_macro(&mut self, i: &'ast TypeMacro) {
-        visit_type_macro(self, i)
+        visit_type_macro(self, i);
     }
     #[cfg(any(feature = "derive", feature = "full"))]
     fn visit_type_never(&mut self, i: &'ast TypeNever) {
-        visit_type_never(self, i)
+        visit_type_never(self, i);
     }
     #[cfg(any(feature = "derive", feature = "full"))]
     fn visit_type_param(&mut self, i: &'ast TypeParam) {
-        visit_type_param(self, i)
+        visit_type_param(self, i);
     }
     #[cfg(any(feature = "derive", feature = "full"))]
     fn visit_type_param_bound(&mut self, i: &'ast TypeParamBound) {
-        visit_type_param_bound(self, i)
+        visit_type_param_bound(self, i);
     }
     #[cfg(any(feature = "derive", feature = "full"))]
     fn visit_type_paren(&mut self, i: &'ast TypeParen) {
-        visit_type_paren(self, i)
+        visit_type_paren(self, i);
     }
     #[cfg(any(feature = "derive", feature = "full"))]
     fn visit_type_path(&mut self, i: &'ast TypePath) {
-        visit_type_path(self, i)
+        visit_type_path(self, i);
     }
     #[cfg(any(feature = "derive", feature = "full"))]
     fn visit_type_ptr(&mut self, i: &'ast TypePtr) {
-        visit_type_ptr(self, i)
+        visit_type_ptr(self, i);
     }
     #[cfg(any(feature = "derive", feature = "full"))]
     fn visit_type_reference(&mut self, i: &'ast TypeReference) {
-        visit_type_reference(self, i)
+        visit_type_reference(self, i);
     }
     #[cfg(any(feature = "derive", feature = "full"))]
     fn visit_type_slice(&mut self, i: &'ast TypeSlice) {
-        visit_type_slice(self, i)
+        visit_type_slice(self, i);
     }
     #[cfg(any(feature = "derive", feature = "full"))]
     fn visit_type_trait_object(&mut self, i: &'ast TypeTraitObject) {
-        visit_type_trait_object(self, i)
+        visit_type_trait_object(self, i);
     }
     #[cfg(any(feature = "derive", feature = "full"))]
     fn visit_type_tuple(&mut self, i: &'ast TypeTuple) {
-        visit_type_tuple(self, i)
+        visit_type_tuple(self, i);
     }
     #[cfg(any(feature = "derive", feature = "full"))]
     fn visit_un_op(&mut self, i: &'ast UnOp) {
-        visit_un_op(self, i)
+        visit_un_op(self, i);
     }
     #[cfg(feature = "full")]
     fn visit_use_glob(&mut self, i: &'ast UseGlob) {
-        visit_use_glob(self, i)
+        visit_use_glob(self, i);
     }
     #[cfg(feature = "full")]
     fn visit_use_group(&mut self, i: &'ast UseGroup) {
-        visit_use_group(self, i)
+        visit_use_group(self, i);
     }
     #[cfg(feature = "full")]
     fn visit_use_name(&mut self, i: &'ast UseName) {
-        visit_use_name(self, i)
+        visit_use_name(self, i);
     }
     #[cfg(feature = "full")]
     fn visit_use_path(&mut self, i: &'ast UsePath) {
-        visit_use_path(self, i)
+        visit_use_path(self, i);
     }
     #[cfg(feature = "full")]
     fn visit_use_rename(&mut self, i: &'ast UseRename) {
-        visit_use_rename(self, i)
+        visit_use_rename(self, i);
     }
     #[cfg(feature = "full")]
     fn visit_use_tree(&mut self, i: &'ast UseTree) {
-        visit_use_tree(self, i)
+        visit_use_tree(self, i);
     }
     #[cfg(any(feature = "derive", feature = "full"))]
     fn visit_variadic(&mut self, i: &'ast Variadic) {
-        visit_variadic(self, i)
+        visit_variadic(self, i);
     }
     #[cfg(any(feature = "derive", feature = "full"))]
     fn visit_variant(&mut self, i: &'ast Variant) {
-        visit_variant(self, i)
+        visit_variant(self, i);
     }
     #[cfg(any(feature = "derive", feature = "full"))]
     fn visit_vis_crate(&mut self, i: &'ast VisCrate) {
-        visit_vis_crate(self, i)
+        visit_vis_crate(self, i);
     }
     #[cfg(any(feature = "derive", feature = "full"))]
     fn visit_vis_public(&mut self, i: &'ast VisPublic) {
-        visit_vis_public(self, i)
+        visit_vis_public(self, i);
     }
     #[cfg(any(feature = "derive", feature = "full"))]
     fn visit_vis_restricted(&mut self, i: &'ast VisRestricted) {
-        visit_vis_restricted(self, i)
+        visit_vis_restricted(self, i);
     }
     #[cfg(any(feature = "derive", feature = "full"))]
     fn visit_visibility(&mut self, i: &'ast Visibility) {
-        visit_visibility(self, i)
+        visit_visibility(self, i);
     }
     #[cfg(any(feature = "derive", feature = "full"))]
     fn visit_where_clause(&mut self, i: &'ast WhereClause) {
-        visit_where_clause(self, i)
+        visit_where_clause(self, i);
     }
     #[cfg(any(feature = "derive", feature = "full"))]
     fn visit_where_predicate(&mut self, i: &'ast WherePredicate) {
-        visit_where_predicate(self, i)
+        visit_where_predicate(self, i);
     }
 }
 #[cfg(any(feature = "derive", feature = "full"))]
@@ -4555,7 +4555,7 @@
 {
     tokens_helper(v, &node.extern_token.span);
     if let Some(it) = &node.name {
-        v.visit_lit_str(it)
+        v.visit_lit_str(it);
     };
 }
 #[cfg(any(feature = "derive", feature = "full"))]
@@ -4566,7 +4566,7 @@
     V: Visit<'ast> + ?Sized,
 {
     if let Some(it) = &node.colon2_token {
-        tokens_helper(v, &it.spans)
+        tokens_helper(v, &it.spans);
     };
     tokens_helper(v, &node.lt_token.spans);
     for el in Punctuated::pairs(&node.args) {
@@ -4584,7 +4584,7 @@
     V: Visit<'ast> + ?Sized,
 {
     for it in &node.attrs {
-        v.visit_attribute(it)
+        v.visit_attribute(it);
     }
     v.visit_pat(&node.pat);
     if let Some(it) = &node.guard {
@@ -4594,7 +4594,7 @@
     tokens_helper(v, &node.fat_arrow_token.spans);
     v.visit_expr(&*node.body);
     if let Some(it) = &node.comma {
-        tokens_helper(v, &it.spans)
+        tokens_helper(v, &it.spans);
     };
 }
 #[cfg(any(feature = "derive", feature = "full"))]
@@ -4626,7 +4626,7 @@
     V: Visit<'ast> + ?Sized,
 {
     for it in &node.attrs {
-        v.visit_attribute(it)
+        v.visit_attribute(it);
     }
     if let Some(it) = &node.name {
         v.visit_ident(&(it).0);
@@ -4742,7 +4742,7 @@
 {
     tokens_helper(v, &node.brace_token.span);
     for it in &node.stmts {
-        v.visit_stmt(it)
+        v.visit_stmt(it);
     }
 }
 #[cfg(any(feature = "derive", feature = "full"))]
@@ -4767,17 +4767,17 @@
     V: Visit<'ast> + ?Sized,
 {
     for it in &node.attrs {
-        v.visit_attribute(it)
+        v.visit_attribute(it);
     }
     tokens_helper(v, &node.const_token.span);
     v.visit_ident(&node.ident);
     tokens_helper(v, &node.colon_token.spans);
     v.visit_type(&node.ty);
     if let Some(it) = &node.eq_token {
-        tokens_helper(v, &it.spans)
+        tokens_helper(v, &it.spans);
     };
     if let Some(it) = &node.default {
-        v.visit_expr(it)
+        v.visit_expr(it);
     };
 }
 #[cfg(any(feature = "derive", feature = "full"))]
@@ -4835,7 +4835,7 @@
     tokens_helper(v, &node.struct_token.span);
     v.visit_fields(&node.fields);
     if let Some(it) = &node.semi_token {
-        tokens_helper(v, &it.spans)
+        tokens_helper(v, &it.spans);
     };
 }
 #[cfg(feature = "derive")]
@@ -4852,7 +4852,7 @@
     V: Visit<'ast> + ?Sized,
 {
     for it in &node.attrs {
-        v.visit_attribute(it)
+        v.visit_attribute(it);
     }
     v.visit_visibility(&node.vis);
     v.visit_ident(&node.ident);
@@ -4994,7 +4994,7 @@
     V: Visit<'ast> + ?Sized,
 {
     for it in &node.attrs {
-        v.visit_attribute(it)
+        v.visit_attribute(it);
     }
     tokens_helper(v, &node.bracket_token.span);
     for el in Punctuated::pairs(&node.elems) {
@@ -5011,7 +5011,7 @@
     V: Visit<'ast> + ?Sized,
 {
     for it in &node.attrs {
-        v.visit_attribute(it)
+        v.visit_attribute(it);
     }
     v.visit_expr(&*node.left);
     tokens_helper(v, &node.eq_token.spans);
@@ -5023,7 +5023,7 @@
     V: Visit<'ast> + ?Sized,
 {
     for it in &node.attrs {
-        v.visit_attribute(it)
+        v.visit_attribute(it);
     }
     v.visit_expr(&*node.left);
     v.visit_bin_op(&node.op);
@@ -5035,11 +5035,11 @@
     V: Visit<'ast> + ?Sized,
 {
     for it in &node.attrs {
-        v.visit_attribute(it)
+        v.visit_attribute(it);
     }
     tokens_helper(v, &node.async_token.span);
     if let Some(it) = &node.capture {
-        tokens_helper(v, &it.span)
+        tokens_helper(v, &it.span);
     };
     v.visit_block(&node.block);
 }
@@ -5049,7 +5049,7 @@
     V: Visit<'ast> + ?Sized,
 {
     for it in &node.attrs {
-        v.visit_attribute(it)
+        v.visit_attribute(it);
     }
     v.visit_expr(&*node.base);
     tokens_helper(v, &node.dot_token.spans);
@@ -5061,7 +5061,7 @@
     V: Visit<'ast> + ?Sized,
 {
     for it in &node.attrs {
-        v.visit_attribute(it)
+        v.visit_attribute(it);
     }
     v.visit_expr(&*node.left);
     v.visit_bin_op(&node.op);
@@ -5073,10 +5073,10 @@
     V: Visit<'ast> + ?Sized,
 {
     for it in &node.attrs {
-        v.visit_attribute(it)
+        v.visit_attribute(it);
     }
     if let Some(it) = &node.label {
-        v.visit_label(it)
+        v.visit_label(it);
     };
     v.visit_block(&node.block);
 }
@@ -5086,7 +5086,7 @@
     V: Visit<'ast> + ?Sized,
 {
     for it in &node.attrs {
-        v.visit_attribute(it)
+        v.visit_attribute(it);
     }
     tokens_helper(v, &node.box_token.span);
     v.visit_expr(&*node.expr);
@@ -5097,14 +5097,14 @@
     V: Visit<'ast> + ?Sized,
 {
     for it in &node.attrs {
-        v.visit_attribute(it)
+        v.visit_attribute(it);
     }
     tokens_helper(v, &node.break_token.span);
     if let Some(it) = &node.label {
-        v.visit_lifetime(it)
+        v.visit_lifetime(it);
     };
     if let Some(it) = &node.expr {
-        v.visit_expr(&**it)
+        v.visit_expr(&**it);
     };
 }
 #[cfg(any(feature = "derive", feature = "full"))]
@@ -5113,7 +5113,7 @@
     V: Visit<'ast> + ?Sized,
 {
     for it in &node.attrs {
-        v.visit_attribute(it)
+        v.visit_attribute(it);
     }
     v.visit_expr(&*node.func);
     tokens_helper(v, &node.paren_token.span);
@@ -5131,7 +5131,7 @@
     V: Visit<'ast> + ?Sized,
 {
     for it in &node.attrs {
-        v.visit_attribute(it)
+        v.visit_attribute(it);
     }
     v.visit_expr(&*node.expr);
     tokens_helper(v, &node.as_token.span);
@@ -5143,16 +5143,16 @@
     V: Visit<'ast> + ?Sized,
 {
     for it in &node.attrs {
-        v.visit_attribute(it)
+        v.visit_attribute(it);
     }
     if let Some(it) = &node.asyncness {
-        tokens_helper(v, &it.span)
+        tokens_helper(v, &it.span);
     };
     if let Some(it) = &node.movability {
-        tokens_helper(v, &it.span)
+        tokens_helper(v, &it.span);
     };
     if let Some(it) = &node.capture {
-        tokens_helper(v, &it.span)
+        tokens_helper(v, &it.span);
     };
     tokens_helper(v, &node.or1_token.spans);
     for el in Punctuated::pairs(&node.inputs) {
@@ -5172,11 +5172,11 @@
     V: Visit<'ast> + ?Sized,
 {
     for it in &node.attrs {
-        v.visit_attribute(it)
+        v.visit_attribute(it);
     }
     tokens_helper(v, &node.continue_token.span);
     if let Some(it) = &node.label {
-        v.visit_lifetime(it)
+        v.visit_lifetime(it);
     };
 }
 #[cfg(any(feature = "derive", feature = "full"))]
@@ -5185,7 +5185,7 @@
     V: Visit<'ast> + ?Sized,
 {
     for it in &node.attrs {
-        v.visit_attribute(it)
+        v.visit_attribute(it);
     }
     v.visit_expr(&*node.base);
     tokens_helper(v, &node.dot_token.spans);
@@ -5197,10 +5197,10 @@
     V: Visit<'ast> + ?Sized,
 {
     for it in &node.attrs {
-        v.visit_attribute(it)
+        v.visit_attribute(it);
     }
     if let Some(it) = &node.label {
-        v.visit_label(it)
+        v.visit_label(it);
     };
     tokens_helper(v, &node.for_token.span);
     v.visit_pat(&node.pat);
@@ -5214,7 +5214,7 @@
     V: Visit<'ast> + ?Sized,
 {
     for it in &node.attrs {
-        v.visit_attribute(it)
+        v.visit_attribute(it);
     }
     tokens_helper(v, &node.group_token.span);
     v.visit_expr(&*node.expr);
@@ -5225,7 +5225,7 @@
     V: Visit<'ast> + ?Sized,
 {
     for it in &node.attrs {
-        v.visit_attribute(it)
+        v.visit_attribute(it);
     }
     tokens_helper(v, &node.if_token.span);
     v.visit_expr(&*node.cond);
@@ -5241,7 +5241,7 @@
     V: Visit<'ast> + ?Sized,
 {
     for it in &node.attrs {
-        v.visit_attribute(it)
+        v.visit_attribute(it);
     }
     v.visit_expr(&*node.expr);
     tokens_helper(v, &node.bracket_token.span);
@@ -5253,7 +5253,7 @@
     V: Visit<'ast> + ?Sized,
 {
     for it in &node.attrs {
-        v.visit_attribute(it)
+        v.visit_attribute(it);
     }
     tokens_helper(v, &node.let_token.span);
     v.visit_pat(&node.pat);
@@ -5266,7 +5266,7 @@
     V: Visit<'ast> + ?Sized,
 {
     for it in &node.attrs {
-        v.visit_attribute(it)
+        v.visit_attribute(it);
     }
     v.visit_lit(&node.lit);
 }
@@ -5276,10 +5276,10 @@
     V: Visit<'ast> + ?Sized,
 {
     for it in &node.attrs {
-        v.visit_attribute(it)
+        v.visit_attribute(it);
     }
     if let Some(it) = &node.label {
-        v.visit_label(it)
+        v.visit_label(it);
     };
     tokens_helper(v, &node.loop_token.span);
     v.visit_block(&node.body);
@@ -5290,7 +5290,7 @@
     V: Visit<'ast> + ?Sized,
 {
     for it in &node.attrs {
-        v.visit_attribute(it)
+        v.visit_attribute(it);
     }
     v.visit_macro(&node.mac);
 }
@@ -5300,13 +5300,13 @@
     V: Visit<'ast> + ?Sized,
 {
     for it in &node.attrs {
-        v.visit_attribute(it)
+        v.visit_attribute(it);
     }
     tokens_helper(v, &node.match_token.span);
     v.visit_expr(&*node.expr);
     tokens_helper(v, &node.brace_token.span);
     for it in &node.arms {
-        v.visit_arm(it)
+        v.visit_arm(it);
     }
 }
 #[cfg(feature = "full")]
@@ -5315,13 +5315,13 @@
     V: Visit<'ast> + ?Sized,
 {
     for it in &node.attrs {
-        v.visit_attribute(it)
+        v.visit_attribute(it);
     }
     v.visit_expr(&*node.receiver);
     tokens_helper(v, &node.dot_token.spans);
     v.visit_ident(&node.method);
     if let Some(it) = &node.turbofish {
-        v.visit_method_turbofish(it)
+        v.visit_method_turbofish(it);
     };
     tokens_helper(v, &node.paren_token.span);
     for el in Punctuated::pairs(&node.args) {
@@ -5338,7 +5338,7 @@
     V: Visit<'ast> + ?Sized,
 {
     for it in &node.attrs {
-        v.visit_attribute(it)
+        v.visit_attribute(it);
     }
     tokens_helper(v, &node.paren_token.span);
     v.visit_expr(&*node.expr);
@@ -5349,10 +5349,10 @@
     V: Visit<'ast> + ?Sized,
 {
     for it in &node.attrs {
-        v.visit_attribute(it)
+        v.visit_attribute(it);
     }
     if let Some(it) = &node.qself {
-        v.visit_qself(it)
+        v.visit_qself(it);
     };
     v.visit_path(&node.path);
 }
@@ -5362,14 +5362,14 @@
     V: Visit<'ast> + ?Sized,
 {
     for it in &node.attrs {
-        v.visit_attribute(it)
+        v.visit_attribute(it);
     }
     if let Some(it) = &node.from {
-        v.visit_expr(&**it)
+        v.visit_expr(&**it);
     };
     v.visit_range_limits(&node.limits);
     if let Some(it) = &node.to {
-        v.visit_expr(&**it)
+        v.visit_expr(&**it);
     };
 }
 #[cfg(feature = "full")]
@@ -5378,11 +5378,11 @@
     V: Visit<'ast> + ?Sized,
 {
     for it in &node.attrs {
-        v.visit_attribute(it)
+        v.visit_attribute(it);
     }
     tokens_helper(v, &node.and_token.spans);
     if let Some(it) = &node.mutability {
-        tokens_helper(v, &it.span)
+        tokens_helper(v, &it.span);
     };
     v.visit_expr(&*node.expr);
 }
@@ -5392,7 +5392,7 @@
     V: Visit<'ast> + ?Sized,
 {
     for it in &node.attrs {
-        v.visit_attribute(it)
+        v.visit_attribute(it);
     }
     tokens_helper(v, &node.bracket_token.span);
     v.visit_expr(&*node.expr);
@@ -5405,11 +5405,11 @@
     V: Visit<'ast> + ?Sized,
 {
     for it in &node.attrs {
-        v.visit_attribute(it)
+        v.visit_attribute(it);
     }
     tokens_helper(v, &node.return_token.span);
     if let Some(it) = &node.expr {
-        v.visit_expr(&**it)
+        v.visit_expr(&**it);
     };
 }
 #[cfg(feature = "full")]
@@ -5418,7 +5418,7 @@
     V: Visit<'ast> + ?Sized,
 {
     for it in &node.attrs {
-        v.visit_attribute(it)
+        v.visit_attribute(it);
     }
     v.visit_path(&node.path);
     tokens_helper(v, &node.brace_token.span);
@@ -5430,10 +5430,10 @@
         }
     }
     if let Some(it) = &node.dot2_token {
-        tokens_helper(v, &it.spans)
+        tokens_helper(v, &it.spans);
     };
     if let Some(it) = &node.rest {
-        v.visit_expr(&**it)
+        v.visit_expr(&**it);
     };
 }
 #[cfg(feature = "full")]
@@ -5442,7 +5442,7 @@
     V: Visit<'ast> + ?Sized,
 {
     for it in &node.attrs {
-        v.visit_attribute(it)
+        v.visit_attribute(it);
     }
     v.visit_expr(&*node.expr);
     tokens_helper(v, &node.question_token.spans);
@@ -5453,7 +5453,7 @@
     V: Visit<'ast> + ?Sized,
 {
     for it in &node.attrs {
-        v.visit_attribute(it)
+        v.visit_attribute(it);
     }
     tokens_helper(v, &node.try_token.span);
     v.visit_block(&node.block);
@@ -5464,7 +5464,7 @@
     V: Visit<'ast> + ?Sized,
 {
     for it in &node.attrs {
-        v.visit_attribute(it)
+        v.visit_attribute(it);
     }
     tokens_helper(v, &node.paren_token.span);
     for el in Punctuated::pairs(&node.elems) {
@@ -5481,7 +5481,7 @@
     V: Visit<'ast> + ?Sized,
 {
     for it in &node.attrs {
-        v.visit_attribute(it)
+        v.visit_attribute(it);
     }
     v.visit_expr(&*node.expr);
     tokens_helper(v, &node.colon_token.spans);
@@ -5493,7 +5493,7 @@
     V: Visit<'ast> + ?Sized,
 {
     for it in &node.attrs {
-        v.visit_attribute(it)
+        v.visit_attribute(it);
     }
     v.visit_un_op(&node.op);
     v.visit_expr(&*node.expr);
@@ -5504,7 +5504,7 @@
     V: Visit<'ast> + ?Sized,
 {
     for it in &node.attrs {
-        v.visit_attribute(it)
+        v.visit_attribute(it);
     }
     tokens_helper(v, &node.unsafe_token.span);
     v.visit_block(&node.block);
@@ -5515,10 +5515,10 @@
     V: Visit<'ast> + ?Sized,
 {
     for it in &node.attrs {
-        v.visit_attribute(it)
+        v.visit_attribute(it);
     }
     if let Some(it) = &node.label {
-        v.visit_label(it)
+        v.visit_label(it);
     };
     tokens_helper(v, &node.while_token.span);
     v.visit_expr(&*node.cond);
@@ -5530,11 +5530,11 @@
     V: Visit<'ast> + ?Sized,
 {
     for it in &node.attrs {
-        v.visit_attribute(it)
+        v.visit_attribute(it);
     }
     tokens_helper(v, &node.yield_token.span);
     if let Some(it) = &node.expr {
-        v.visit_expr(&**it)
+        v.visit_expr(&**it);
     };
 }
 #[cfg(any(feature = "derive", feature = "full"))]
@@ -5543,14 +5543,14 @@
     V: Visit<'ast> + ?Sized,
 {
     for it in &node.attrs {
-        v.visit_attribute(it)
+        v.visit_attribute(it);
     }
     v.visit_visibility(&node.vis);
     if let Some(it) = &node.ident {
-        v.visit_ident(it)
+        v.visit_ident(it);
     };
     if let Some(it) = &node.colon_token {
-        tokens_helper(v, &it.spans)
+        tokens_helper(v, &it.spans);
     };
     v.visit_type(&node.ty);
 }
@@ -5560,11 +5560,11 @@
     V: Visit<'ast> + ?Sized,
 {
     for it in &node.attrs {
-        v.visit_attribute(it)
+        v.visit_attribute(it);
     }
     v.visit_member(&node.member);
     if let Some(it) = &node.colon_token {
-        tokens_helper(v, &it.spans)
+        tokens_helper(v, &it.spans);
     };
     v.visit_pat(&*node.pat);
 }
@@ -5574,11 +5574,11 @@
     V: Visit<'ast> + ?Sized,
 {
     for it in &node.attrs {
-        v.visit_attribute(it)
+        v.visit_attribute(it);
     }
     v.visit_member(&node.member);
     if let Some(it) = &node.colon_token {
-        tokens_helper(v, &it.spans)
+        tokens_helper(v, &it.spans);
     };
     v.visit_expr(&node.expr);
 }
@@ -5632,10 +5632,10 @@
 {
     skip!(node.shebang);
     for it in &node.attrs {
-        v.visit_attribute(it)
+        v.visit_attribute(it);
     }
     for it in &node.items {
-        v.visit_item(it)
+        v.visit_item(it);
     }
 }
 #[cfg(feature = "full")]
@@ -5682,7 +5682,7 @@
     V: Visit<'ast> + ?Sized,
 {
     for it in &node.attrs {
-        v.visit_attribute(it)
+        v.visit_attribute(it);
     }
     v.visit_visibility(&node.vis);
     v.visit_signature(&node.sig);
@@ -5694,11 +5694,11 @@
     V: Visit<'ast> + ?Sized,
 {
     for it in &node.attrs {
-        v.visit_attribute(it)
+        v.visit_attribute(it);
     }
     v.visit_macro(&node.mac);
     if let Some(it) = &node.semi_token {
-        tokens_helper(v, &it.spans)
+        tokens_helper(v, &it.spans);
     };
 }
 #[cfg(feature = "full")]
@@ -5707,12 +5707,12 @@
     V: Visit<'ast> + ?Sized,
 {
     for it in &node.attrs {
-        v.visit_attribute(it)
+        v.visit_attribute(it);
     }
     v.visit_visibility(&node.vis);
     tokens_helper(v, &node.static_token.span);
     if let Some(it) = &node.mutability {
-        tokens_helper(v, &it.span)
+        tokens_helper(v, &it.span);
     };
     v.visit_ident(&node.ident);
     tokens_helper(v, &node.colon_token.spans);
@@ -5725,7 +5725,7 @@
     V: Visit<'ast> + ?Sized,
 {
     for it in &node.attrs {
-        v.visit_attribute(it)
+        v.visit_attribute(it);
     }
     v.visit_visibility(&node.vis);
     tokens_helper(v, &node.type_token.span);
@@ -5792,7 +5792,7 @@
     V: Visit<'ast> + ?Sized,
 {
     if let Some(it) = &node.lt_token {
-        tokens_helper(v, &it.spans)
+        tokens_helper(v, &it.spans);
     };
     for el in Punctuated::pairs(&node.params) {
         let (it, p) = el.into_tuple();
@@ -5802,10 +5802,10 @@
         }
     }
     if let Some(it) = &node.gt_token {
-        tokens_helper(v, &it.spans)
+        tokens_helper(v, &it.spans);
     };
     if let Some(it) = &node.where_clause {
-        v.visit_where_clause(it)
+        v.visit_where_clause(it);
     };
 }
 pub fn visit_ident<'ast, V>(v: &mut V, node: &'ast Ident)
@@ -5844,11 +5844,11 @@
     V: Visit<'ast> + ?Sized,
 {
     for it in &node.attrs {
-        v.visit_attribute(it)
+        v.visit_attribute(it);
     }
     v.visit_visibility(&node.vis);
     if let Some(it) = &node.defaultness {
-        tokens_helper(v, &it.span)
+        tokens_helper(v, &it.span);
     };
     tokens_helper(v, &node.const_token.span);
     v.visit_ident(&node.ident);
@@ -5864,11 +5864,11 @@
     V: Visit<'ast> + ?Sized,
 {
     for it in &node.attrs {
-        v.visit_attribute(it)
+        v.visit_attribute(it);
     }
     v.visit_macro(&node.mac);
     if let Some(it) = &node.semi_token {
-        tokens_helper(v, &it.spans)
+        tokens_helper(v, &it.spans);
     };
 }
 #[cfg(feature = "full")]
@@ -5877,11 +5877,11 @@
     V: Visit<'ast> + ?Sized,
 {
     for it in &node.attrs {
-        v.visit_attribute(it)
+        v.visit_attribute(it);
     }
     v.visit_visibility(&node.vis);
     if let Some(it) = &node.defaultness {
-        tokens_helper(v, &it.span)
+        tokens_helper(v, &it.span);
     };
     v.visit_signature(&node.sig);
     v.visit_block(&node.block);
@@ -5892,11 +5892,11 @@
     V: Visit<'ast> + ?Sized,
 {
     for it in &node.attrs {
-        v.visit_attribute(it)
+        v.visit_attribute(it);
     }
     v.visit_visibility(&node.vis);
     if let Some(it) = &node.defaultness {
-        tokens_helper(v, &it.span)
+        tokens_helper(v, &it.span);
     };
     tokens_helper(v, &node.type_token.span);
     v.visit_ident(&node.ident);
@@ -5979,7 +5979,7 @@
     V: Visit<'ast> + ?Sized,
 {
     for it in &node.attrs {
-        v.visit_attribute(it)
+        v.visit_attribute(it);
     }
     v.visit_visibility(&node.vis);
     tokens_helper(v, &node.const_token.span);
@@ -5996,7 +5996,7 @@
     V: Visit<'ast> + ?Sized,
 {
     for it in &node.attrs {
-        v.visit_attribute(it)
+        v.visit_attribute(it);
     }
     v.visit_visibility(&node.vis);
     tokens_helper(v, &node.enum_token.span);
@@ -6017,7 +6017,7 @@
     V: Visit<'ast> + ?Sized,
 {
     for it in &node.attrs {
-        v.visit_attribute(it)
+        v.visit_attribute(it);
     }
     v.visit_visibility(&node.vis);
     tokens_helper(v, &node.extern_token.span);
@@ -6035,7 +6035,7 @@
     V: Visit<'ast> + ?Sized,
 {
     for it in &node.attrs {
-        v.visit_attribute(it)
+        v.visit_attribute(it);
     }
     v.visit_visibility(&node.vis);
     v.visit_signature(&node.sig);
@@ -6047,12 +6047,12 @@
     V: Visit<'ast> + ?Sized,
 {
     for it in &node.attrs {
-        v.visit_attribute(it)
+        v.visit_attribute(it);
     }
     v.visit_abi(&node.abi);
     tokens_helper(v, &node.brace_token.span);
     for it in &node.items {
-        v.visit_foreign_item(it)
+        v.visit_foreign_item(it);
     }
 }
 #[cfg(feature = "full")]
@@ -6061,19 +6061,19 @@
     V: Visit<'ast> + ?Sized,
 {
     for it in &node.attrs {
-        v.visit_attribute(it)
+        v.visit_attribute(it);
     }
     if let Some(it) = &node.defaultness {
-        tokens_helper(v, &it.span)
+        tokens_helper(v, &it.span);
     };
     if let Some(it) = &node.unsafety {
-        tokens_helper(v, &it.span)
+        tokens_helper(v, &it.span);
     };
     tokens_helper(v, &node.impl_token.span);
     v.visit_generics(&node.generics);
     if let Some(it) = &node.trait_ {
         if let Some(it) = &(it).0 {
-            tokens_helper(v, &it.spans)
+            tokens_helper(v, &it.spans);
         };
         v.visit_path(&(it).1);
         tokens_helper(v, &(it).2.span);
@@ -6081,7 +6081,7 @@
     v.visit_type(&*node.self_ty);
     tokens_helper(v, &node.brace_token.span);
     for it in &node.items {
-        v.visit_impl_item(it)
+        v.visit_impl_item(it);
     }
 }
 #[cfg(feature = "full")]
@@ -6090,14 +6090,14 @@
     V: Visit<'ast> + ?Sized,
 {
     for it in &node.attrs {
-        v.visit_attribute(it)
+        v.visit_attribute(it);
     }
     if let Some(it) = &node.ident {
-        v.visit_ident(it)
+        v.visit_ident(it);
     };
     v.visit_macro(&node.mac);
     if let Some(it) = &node.semi_token {
-        tokens_helper(v, &it.spans)
+        tokens_helper(v, &it.spans);
     };
 }
 #[cfg(feature = "full")]
@@ -6106,7 +6106,7 @@
     V: Visit<'ast> + ?Sized,
 {
     for it in &node.attrs {
-        v.visit_attribute(it)
+        v.visit_attribute(it);
     }
     v.visit_visibility(&node.vis);
     tokens_helper(v, &node.macro_token.span);
@@ -6119,7 +6119,7 @@
     V: Visit<'ast> + ?Sized,
 {
     for it in &node.attrs {
-        v.visit_attribute(it)
+        v.visit_attribute(it);
     }
     v.visit_visibility(&node.vis);
     tokens_helper(v, &node.mod_token.span);
@@ -6127,11 +6127,11 @@
     if let Some(it) = &node.content {
         tokens_helper(v, &(it).0.span);
         for it in &(it).1 {
-            v.visit_item(it)
+            v.visit_item(it);
         }
     };
     if let Some(it) = &node.semi {
-        tokens_helper(v, &it.spans)
+        tokens_helper(v, &it.spans);
     };
 }
 #[cfg(feature = "full")]
@@ -6140,12 +6140,12 @@
     V: Visit<'ast> + ?Sized,
 {
     for it in &node.attrs {
-        v.visit_attribute(it)
+        v.visit_attribute(it);
     }
     v.visit_visibility(&node.vis);
     tokens_helper(v, &node.static_token.span);
     if let Some(it) = &node.mutability {
-        tokens_helper(v, &it.span)
+        tokens_helper(v, &it.span);
     };
     v.visit_ident(&node.ident);
     tokens_helper(v, &node.colon_token.spans);
@@ -6160,7 +6160,7 @@
     V: Visit<'ast> + ?Sized,
 {
     for it in &node.attrs {
-        v.visit_attribute(it)
+        v.visit_attribute(it);
     }
     v.visit_visibility(&node.vis);
     tokens_helper(v, &node.struct_token.span);
@@ -6168,7 +6168,7 @@
     v.visit_generics(&node.generics);
     v.visit_fields(&node.fields);
     if let Some(it) = &node.semi_token {
-        tokens_helper(v, &it.spans)
+        tokens_helper(v, &it.spans);
     };
 }
 #[cfg(feature = "full")]
@@ -6177,20 +6177,20 @@
     V: Visit<'ast> + ?Sized,
 {
     for it in &node.attrs {
-        v.visit_attribute(it)
+        v.visit_attribute(it);
     }
     v.visit_visibility(&node.vis);
     if let Some(it) = &node.unsafety {
-        tokens_helper(v, &it.span)
+        tokens_helper(v, &it.span);
     };
     if let Some(it) = &node.auto_token {
-        tokens_helper(v, &it.span)
+        tokens_helper(v, &it.span);
     };
     tokens_helper(v, &node.trait_token.span);
     v.visit_ident(&node.ident);
     v.visit_generics(&node.generics);
     if let Some(it) = &node.colon_token {
-        tokens_helper(v, &it.spans)
+        tokens_helper(v, &it.spans);
     };
     for el in Punctuated::pairs(&node.supertraits) {
         let (it, p) = el.into_tuple();
@@ -6201,7 +6201,7 @@
     }
     tokens_helper(v, &node.brace_token.span);
     for it in &node.items {
-        v.visit_trait_item(it)
+        v.visit_trait_item(it);
     }
 }
 #[cfg(feature = "full")]
@@ -6210,7 +6210,7 @@
     V: Visit<'ast> + ?Sized,
 {
     for it in &node.attrs {
-        v.visit_attribute(it)
+        v.visit_attribute(it);
     }
     v.visit_visibility(&node.vis);
     tokens_helper(v, &node.trait_token.span);
@@ -6232,7 +6232,7 @@
     V: Visit<'ast> + ?Sized,
 {
     for it in &node.attrs {
-        v.visit_attribute(it)
+        v.visit_attribute(it);
     }
     v.visit_visibility(&node.vis);
     tokens_helper(v, &node.type_token.span);
@@ -6248,7 +6248,7 @@
     V: Visit<'ast> + ?Sized,
 {
     for it in &node.attrs {
-        v.visit_attribute(it)
+        v.visit_attribute(it);
     }
     v.visit_visibility(&node.vis);
     tokens_helper(v, &node.union_token.span);
@@ -6262,12 +6262,12 @@
     V: Visit<'ast> + ?Sized,
 {
     for it in &node.attrs {
-        v.visit_attribute(it)
+        v.visit_attribute(it);
     }
     v.visit_visibility(&node.vis);
     tokens_helper(v, &node.use_token.span);
     if let Some(it) = &node.leading_colon {
-        tokens_helper(v, &it.spans)
+        tokens_helper(v, &it.spans);
     };
     v.visit_use_tree(&node.tree);
     tokens_helper(v, &node.semi_token.spans);
@@ -6293,11 +6293,11 @@
     V: Visit<'ast> + ?Sized,
 {
     for it in &node.attrs {
-        v.visit_attribute(it)
+        v.visit_attribute(it);
     }
     v.visit_lifetime(&node.lifetime);
     if let Some(it) = &node.colon_token {
-        tokens_helper(v, &it.spans)
+        tokens_helper(v, &it.spans);
     };
     for el in Punctuated::pairs(&node.bounds) {
         let (it, p) = el.into_tuple();
@@ -6381,7 +6381,7 @@
     V: Visit<'ast> + ?Sized,
 {
     for it in &node.attrs {
-        v.visit_attribute(it)
+        v.visit_attribute(it);
     }
     tokens_helper(v, &node.let_token.span);
     v.visit_pat(&node.pat);
@@ -6583,7 +6583,7 @@
     V: Visit<'ast> + ?Sized,
 {
     for it in &node.attrs {
-        v.visit_attribute(it)
+        v.visit_attribute(it);
     }
     tokens_helper(v, &node.box_token.span);
     v.visit_pat(&*node.pat);
@@ -6594,13 +6594,13 @@
     V: Visit<'ast> + ?Sized,
 {
     for it in &node.attrs {
-        v.visit_attribute(it)
+        v.visit_attribute(it);
     }
     if let Some(it) = &node.by_ref {
-        tokens_helper(v, &it.span)
+        tokens_helper(v, &it.span);
     };
     if let Some(it) = &node.mutability {
-        tokens_helper(v, &it.span)
+        tokens_helper(v, &it.span);
     };
     v.visit_ident(&node.ident);
     if let Some(it) = &node.subpat {
@@ -6614,7 +6614,7 @@
     V: Visit<'ast> + ?Sized,
 {
     for it in &node.attrs {
-        v.visit_attribute(it)
+        v.visit_attribute(it);
     }
     v.visit_expr(&*node.expr);
 }
@@ -6624,7 +6624,7 @@
     V: Visit<'ast> + ?Sized,
 {
     for it in &node.attrs {
-        v.visit_attribute(it)
+        v.visit_attribute(it);
     }
     v.visit_macro(&node.mac);
 }
@@ -6634,10 +6634,10 @@
     V: Visit<'ast> + ?Sized,
 {
     for it in &node.attrs {
-        v.visit_attribute(it)
+        v.visit_attribute(it);
     }
     if let Some(it) = &node.leading_vert {
-        tokens_helper(v, &it.spans)
+        tokens_helper(v, &it.spans);
     };
     for el in Punctuated::pairs(&node.cases) {
         let (it, p) = el.into_tuple();
@@ -6653,10 +6653,10 @@
     V: Visit<'ast> + ?Sized,
 {
     for it in &node.attrs {
-        v.visit_attribute(it)
+        v.visit_attribute(it);
     }
     if let Some(it) = &node.qself {
-        v.visit_qself(it)
+        v.visit_qself(it);
     };
     v.visit_path(&node.path);
 }
@@ -6666,7 +6666,7 @@
     V: Visit<'ast> + ?Sized,
 {
     for it in &node.attrs {
-        v.visit_attribute(it)
+        v.visit_attribute(it);
     }
     v.visit_expr(&*node.lo);
     v.visit_range_limits(&node.limits);
@@ -6678,11 +6678,11 @@
     V: Visit<'ast> + ?Sized,
 {
     for it in &node.attrs {
-        v.visit_attribute(it)
+        v.visit_attribute(it);
     }
     tokens_helper(v, &node.and_token.spans);
     if let Some(it) = &node.mutability {
-        tokens_helper(v, &it.span)
+        tokens_helper(v, &it.span);
     };
     v.visit_pat(&*node.pat);
 }
@@ -6692,7 +6692,7 @@
     V: Visit<'ast> + ?Sized,
 {
     for it in &node.attrs {
-        v.visit_attribute(it)
+        v.visit_attribute(it);
     }
     tokens_helper(v, &node.dot2_token.spans);
 }
@@ -6702,7 +6702,7 @@
     V: Visit<'ast> + ?Sized,
 {
     for it in &node.attrs {
-        v.visit_attribute(it)
+        v.visit_attribute(it);
     }
     tokens_helper(v, &node.bracket_token.span);
     for el in Punctuated::pairs(&node.elems) {
@@ -6719,7 +6719,7 @@
     V: Visit<'ast> + ?Sized,
 {
     for it in &node.attrs {
-        v.visit_attribute(it)
+        v.visit_attribute(it);
     }
     v.visit_path(&node.path);
     tokens_helper(v, &node.brace_token.span);
@@ -6731,7 +6731,7 @@
         }
     }
     if let Some(it) = &node.dot2_token {
-        tokens_helper(v, &it.spans)
+        tokens_helper(v, &it.spans);
     };
 }
 #[cfg(feature = "full")]
@@ -6740,7 +6740,7 @@
     V: Visit<'ast> + ?Sized,
 {
     for it in &node.attrs {
-        v.visit_attribute(it)
+        v.visit_attribute(it);
     }
     tokens_helper(v, &node.paren_token.span);
     for el in Punctuated::pairs(&node.elems) {
@@ -6757,7 +6757,7 @@
     V: Visit<'ast> + ?Sized,
 {
     for it in &node.attrs {
-        v.visit_attribute(it)
+        v.visit_attribute(it);
     }
     v.visit_path(&node.path);
     v.visit_pat_tuple(&node.pat);
@@ -6768,7 +6768,7 @@
     V: Visit<'ast> + ?Sized,
 {
     for it in &node.attrs {
-        v.visit_attribute(it)
+        v.visit_attribute(it);
     }
     v.visit_pat(&*node.pat);
     tokens_helper(v, &node.colon_token.spans);
@@ -6780,7 +6780,7 @@
     V: Visit<'ast> + ?Sized,
 {
     for it in &node.attrs {
-        v.visit_attribute(it)
+        v.visit_attribute(it);
     }
     tokens_helper(v, &node.underscore_token.spans);
 }
@@ -6790,7 +6790,7 @@
     V: Visit<'ast> + ?Sized,
 {
     if let Some(it) = &node.leading_colon {
-        tokens_helper(v, &it.spans)
+        tokens_helper(v, &it.spans);
     };
     for el in Punctuated::pairs(&node.segments) {
         let (it, p) = el.into_tuple();
@@ -6853,7 +6853,7 @@
     V: Visit<'ast> + ?Sized,
 {
     if let Some(it) = &node.lifetimes {
-        v.visit_bound_lifetimes(it)
+        v.visit_bound_lifetimes(it);
     };
     v.visit_type(&node.bounded_ty);
     tokens_helper(v, &node.colon_token.spans);
@@ -6874,7 +6874,7 @@
     v.visit_type(&*node.ty);
     skip!(node.position);
     if let Some(it) = &node.as_token {
-        tokens_helper(v, &it.span)
+        tokens_helper(v, &it.span);
     };
     tokens_helper(v, &node.gt_token.spans);
 }
@@ -6898,16 +6898,16 @@
     V: Visit<'ast> + ?Sized,
 {
     for it in &node.attrs {
-        v.visit_attribute(it)
+        v.visit_attribute(it);
     }
     if let Some(it) = &node.reference {
         tokens_helper(v, &(it).0.spans);
         if let Some(it) = &(it).1 {
-            v.visit_lifetime(it)
+            v.visit_lifetime(it);
         };
     };
     if let Some(it) = &node.mutability {
-        tokens_helper(v, &it.span)
+        tokens_helper(v, &it.span);
     };
     tokens_helper(v, &node.self_token.span);
 }
@@ -6930,16 +6930,16 @@
     V: Visit<'ast> + ?Sized,
 {
     if let Some(it) = &node.constness {
-        tokens_helper(v, &it.span)
+        tokens_helper(v, &it.span);
     };
     if let Some(it) = &node.asyncness {
-        tokens_helper(v, &it.span)
+        tokens_helper(v, &it.span);
     };
     if let Some(it) = &node.unsafety {
-        tokens_helper(v, &it.span)
+        tokens_helper(v, &it.span);
     };
     if let Some(it) = &node.abi {
-        v.visit_abi(it)
+        v.visit_abi(it);
     };
     tokens_helper(v, &node.fn_token.span);
     v.visit_ident(&node.ident);
@@ -6953,7 +6953,7 @@
         }
     }
     if let Some(it) = &node.variadic {
-        v.visit_variadic(it)
+        v.visit_variadic(it);
     };
     v.visit_return_type(&node.output);
 }
@@ -6989,11 +6989,11 @@
     V: Visit<'ast> + ?Sized,
 {
     if let Some(it) = &node.paren_token {
-        tokens_helper(v, &it.span)
+        tokens_helper(v, &it.span);
     };
     v.visit_trait_bound_modifier(&node.modifier);
     if let Some(it) = &node.lifetimes {
-        v.visit_bound_lifetimes(it)
+        v.visit_bound_lifetimes(it);
     };
     v.visit_path(&node.path);
 }
@@ -7039,7 +7039,7 @@
     V: Visit<'ast> + ?Sized,
 {
     for it in &node.attrs {
-        v.visit_attribute(it)
+        v.visit_attribute(it);
     }
     tokens_helper(v, &node.const_token.span);
     v.visit_ident(&node.ident);
@@ -7057,11 +7057,11 @@
     V: Visit<'ast> + ?Sized,
 {
     for it in &node.attrs {
-        v.visit_attribute(it)
+        v.visit_attribute(it);
     }
     v.visit_macro(&node.mac);
     if let Some(it) = &node.semi_token {
-        tokens_helper(v, &it.spans)
+        tokens_helper(v, &it.spans);
     };
 }
 #[cfg(feature = "full")]
@@ -7070,14 +7070,14 @@
     V: Visit<'ast> + ?Sized,
 {
     for it in &node.attrs {
-        v.visit_attribute(it)
+        v.visit_attribute(it);
     }
     v.visit_signature(&node.sig);
     if let Some(it) = &node.default {
-        v.visit_block(it)
+        v.visit_block(it);
     };
     if let Some(it) = &node.semi_token {
-        tokens_helper(v, &it.spans)
+        tokens_helper(v, &it.spans);
     };
 }
 #[cfg(feature = "full")]
@@ -7086,13 +7086,13 @@
     V: Visit<'ast> + ?Sized,
 {
     for it in &node.attrs {
-        v.visit_attribute(it)
+        v.visit_attribute(it);
     }
     tokens_helper(v, &node.type_token.span);
     v.visit_ident(&node.ident);
     v.visit_generics(&node.generics);
     if let Some(it) = &node.colon_token {
-        tokens_helper(v, &it.spans)
+        tokens_helper(v, &it.spans);
     };
     for el in Punctuated::pairs(&node.bounds) {
         let (it, p) = el.into_tuple();
@@ -7177,13 +7177,13 @@
     V: Visit<'ast> + ?Sized,
 {
     if let Some(it) = &node.lifetimes {
-        v.visit_bound_lifetimes(it)
+        v.visit_bound_lifetimes(it);
     };
     if let Some(it) = &node.unsafety {
-        tokens_helper(v, &it.span)
+        tokens_helper(v, &it.span);
     };
     if let Some(it) = &node.abi {
-        v.visit_abi(it)
+        v.visit_abi(it);
     };
     tokens_helper(v, &node.fn_token.span);
     tokens_helper(v, &node.paren_token.span);
@@ -7195,7 +7195,7 @@
         }
     }
     if let Some(it) = &node.variadic {
-        v.visit_variadic(it)
+        v.visit_variadic(it);
     };
     v.visit_return_type(&node.output);
 }
@@ -7248,11 +7248,11 @@
     V: Visit<'ast> + ?Sized,
 {
     for it in &node.attrs {
-        v.visit_attribute(it)
+        v.visit_attribute(it);
     }
     v.visit_ident(&node.ident);
     if let Some(it) = &node.colon_token {
-        tokens_helper(v, &it.spans)
+        tokens_helper(v, &it.spans);
     };
     for el in Punctuated::pairs(&node.bounds) {
         let (it, p) = el.into_tuple();
@@ -7262,10 +7262,10 @@
         }
     }
     if let Some(it) = &node.eq_token {
-        tokens_helper(v, &it.spans)
+        tokens_helper(v, &it.spans);
     };
     if let Some(it) = &node.default {
-        v.visit_type(it)
+        v.visit_type(it);
     };
 }
 #[cfg(any(feature = "derive", feature = "full"))]
@@ -7296,7 +7296,7 @@
     V: Visit<'ast> + ?Sized,
 {
     if let Some(it) = &node.qself {
-        v.visit_qself(it)
+        v.visit_qself(it);
     };
     v.visit_path(&node.path);
 }
@@ -7307,10 +7307,10 @@
 {
     tokens_helper(v, &node.star_token.spans);
     if let Some(it) = &node.const_token {
-        tokens_helper(v, &it.span)
+        tokens_helper(v, &it.span);
     };
     if let Some(it) = &node.mutability {
-        tokens_helper(v, &it.span)
+        tokens_helper(v, &it.span);
     };
     v.visit_type(&*node.elem);
 }
@@ -7321,10 +7321,10 @@
 {
     tokens_helper(v, &node.and_token.spans);
     if let Some(it) = &node.lifetime {
-        v.visit_lifetime(it)
+        v.visit_lifetime(it);
     };
     if let Some(it) = &node.mutability {
-        tokens_helper(v, &it.span)
+        tokens_helper(v, &it.span);
     };
     v.visit_type(&*node.elem);
 }
@@ -7342,7 +7342,7 @@
     V: Visit<'ast> + ?Sized,
 {
     if let Some(it) = &node.dyn_token {
-        tokens_helper(v, &it.span)
+        tokens_helper(v, &it.span);
     };
     for el in Punctuated::pairs(&node.bounds) {
         let (it, p) = el.into_tuple();
@@ -7458,7 +7458,7 @@
     V: Visit<'ast> + ?Sized,
 {
     for it in &node.attrs {
-        v.visit_attribute(it)
+        v.visit_attribute(it);
     }
     tokens_helper(v, &node.dots.spans);
 }
@@ -7468,7 +7468,7 @@
     V: Visit<'ast> + ?Sized,
 {
     for it in &node.attrs {
-        v.visit_attribute(it)
+        v.visit_attribute(it);
     }
     v.visit_ident(&node.ident);
     v.visit_fields(&node.fields);
@@ -7499,7 +7499,7 @@
     tokens_helper(v, &node.pub_token.span);
     tokens_helper(v, &node.paren_token.span);
     if let Some(it) = &node.in_token {
-        tokens_helper(v, &it.span)
+        tokens_helper(v, &it.span);
     };
     v.visit_path(&*node.path);
 }
@@ -7553,4 +7553,5 @@
     }
 }
 

-

\ No newline at end of file
+
+ \ No newline at end of file diff --git a/src/syn/generics.rs.html b/src/syn/generics.rs.html index d909d3b..1d52860 100644 --- a/src/syn/generics.rs.html +++ b/src/syn/generics.rs.html @@ -1,7 +1,7 @@ -generics.rs - source +generics.rs - source -
   1
+
   1
    2
    3
    4
@@ -1288,6 +1288,9 @@
 1285
 1286
 1287
+1288
+1289
+1290
 
 use super::*;
 use crate::punctuated::{Iter, IterMut, Punctuated};
@@ -1463,17 +1466,10 @@
 
     /// Initializes an empty `where`-clause if there is not one present already.
     pub fn make_where_clause(&mut self) -> &mut WhereClause {
-        // This is Option::get_or_insert_with in Rust 1.20.
-        if self.where_clause.is_none() {
-            self.where_clause = Some(WhereClause {
-                where_token: <Token![where]>::default(),
-                predicates: Punctuated::new(),
-            });
-        }
-        match &mut self.where_clause {
-            Some(where_clause) => where_clause,
-            None => unreachable!(),
-        }
+        self.where_clause.get_or_insert_with(|| WhereClause {
+            where_token: <Token![where]>::default(),
+            predicates: Punctuated::new(),
+        })
     }
 }
 
@@ -1889,6 +1885,7 @@
 #[cfg(feature = "parsing")]
 pub mod parsing {
     use super::*;
+    use crate::ext::IdentExt;
     use crate::parse::{Parse, ParseStream, Result};
 
     #[cfg_attr(doc_cfg, doc(cfg(feature = "parsing")))]
@@ -1923,6 +1920,15 @@
                         attrs,
                         ..input.parse()?
                     }));
+                } else if input.peek(Token![_]) {
+                    params.push_value(GenericParam::Type(TypeParam {
+                        attrs,
+                        ident: input.call(Ident::parse_any)?,
+                        colon_token: None,
+                        bounds: Punctuated::new(),
+                        eq_token: None,
+                        default: None,
+                    }));
                 } else {
                     return Err(lookahead.error());
                 }
@@ -2161,7 +2167,7 @@
                 eq_token: {
                     if input.peek(Token![=]) {
                         let eq_token = input.parse()?;
-                        default = Some(input.parse::<Expr>()?);
+                        default = Some(path::parsing::const_argument(input)?);
                         Some(eq_token)
                     } else {
                         None
@@ -2577,4 +2583,5 @@
     }
 }
 

-

\ No newline at end of file
+
+ \ No newline at end of file diff --git a/src/syn/group.rs.html b/src/syn/group.rs.html index 27839a1..9cafa36 100644 --- a/src/syn/group.rs.html +++ b/src/syn/group.rs.html @@ -1,7 +1,7 @@ -group.rs - source +group.rs - source -
  1
+
  1
   2
   3
   4
@@ -567,4 +567,5 @@
     };
 }
 

-

\ No newline at end of file
+
+ \ No newline at end of file diff --git a/src/syn/ident.rs.html b/src/syn/ident.rs.html index c82082b..a2d1467 100644 --- a/src/syn/ident.rs.html +++ b/src/syn/ident.rs.html @@ -1,7 +1,7 @@ -ident.rs - source +ident.rs - source -
  1
+
  1
   2
   3
   4
@@ -207,4 +207,5 @@
     true
 }
 

-

\ No newline at end of file
+
+ \ No newline at end of file diff --git a/src/syn/lib.rs.html b/src/syn/lib.rs.html index f4bb062..840c4dd 100644 --- a/src/syn/lib.rs.html +++ b/src/syn/lib.rs.html @@ -1,1000 +1,1006 @@ -lib.rs - source +lib.rs - source -
  1
-  2
-  3
-  4
-  5
-  6
-  7
-  8
-  9
- 10
- 11
- 12
- 13
- 14
- 15
- 16
- 17
- 18
- 19
- 20
- 21
- 22
- 23
- 24
- 25
- 26
- 27
- 28
- 29
- 30
- 31
- 32
- 33
- 34
- 35
- 36
- 37
- 38
- 39
- 40
- 41
- 42
- 43
- 44
- 45
- 46
- 47
- 48
- 49
- 50
- 51
- 52
- 53
- 54
- 55
- 56
- 57
- 58
- 59
- 60
- 61
- 62
- 63
- 64
- 65
- 66
- 67
- 68
- 69
- 70
- 71
- 72
- 73
- 74
- 75
- 76
- 77
- 78
- 79
- 80
- 81
- 82
- 83
- 84
- 85
- 86
- 87
- 88
- 89
- 90
- 91
- 92
- 93
- 94
- 95
- 96
- 97
- 98
- 99
-100
-101
-102
-103
-104
-105
-106
-107
-108
-109
-110
-111
-112
-113
-114
-115
-116
-117
-118
-119
-120
-121
-122
-123
-124
-125
-126
-127
-128
-129
-130
-131
-132
-133
-134
-135
-136
-137
-138
-139
-140
-141
-142
-143
-144
-145
-146
-147
-148
-149
-150
-151
-152
-153
-154
-155
-156
-157
-158
-159
-160
-161
-162
-163
-164
-165
-166
-167
-168
-169
-170
-171
-172
-173
-174
-175
-176
-177
-178
-179
-180
-181
-182
-183
-184
-185
-186
-187
-188
-189
-190
-191
-192
-193
-194
-195
-196
-197
-198
-199
-200
-201
-202
-203
-204
-205
-206
-207
-208
-209
-210
-211
-212
-213
-214
-215
-216
-217
-218
-219
-220
-221
-222
-223
-224
-225
-226
-227
-228
-229
-230
-231
-232
-233
-234
-235
-236
-237
-238
-239
-240
-241
-242
-243
-244
-245
-246
-247
-248
-249
-250
-251
-252
-253
-254
-255
-256
-257
-258
-259
-260
-261
-262
-263
-264
-265
-266
-267
-268
-269
-270
-271
-272
-273
-274
-275
-276
-277
-278
-279
-280
-281
-282
-283
-284
-285
-286
-287
-288
-289
-290
-291
-292
-293
-294
-295
-296
-297
-298
-299
-300
-301
-302
-303
-304
-305
-306
-307
-308
-309
-310
-311
-312
-313
-314
-315
-316
-317
-318
-319
-320
-321
-322
-323
-324
-325
-326
-327
-328
-329
-330
-331
-332
-333
-334
-335
-336
-337
-338
-339
-340
-341
-342
-343
-344
-345
-346
-347
-348
-349
-350
-351
-352
-353
-354
-355
-356
-357
-358
-359
-360
-361
-362
-363
-364
-365
-366
-367
-368
-369
-370
-371
-372
-373
-374
-375
-376
-377
-378
-379
-380
-381
-382
-383
-384
-385
-386
-387
-388
-389
-390
-391
-392
-393
-394
-395
-396
-397
-398
-399
-400
-401
-402
-403
-404
-405
-406
-407
-408
-409
-410
-411
-412
-413
-414
-415
-416
-417
-418
-419
-420
-421
-422
-423
-424
-425
-426
-427
-428
-429
-430
-431
-432
-433
-434
-435
-436
-437
-438
-439
-440
-441
-442
-443
-444
-445
-446
-447
-448
-449
-450
-451
-452
-453
-454
-455
-456
-457
-458
-459
-460
-461
-462
-463
-464
-465
-466
-467
-468
-469
-470
-471
-472
-473
-474
-475
-476
-477
-478
-479
-480
-481
-482
-483
-484
-485
-486
-487
-488
-489
-490
-491
-492
-493
-494
-495
-496
-497
-498
-499
-500
-501
-502
-503
-504
-505
-506
-507
-508
-509
-510
-511
-512
-513
-514
-515
-516
-517
-518
-519
-520
-521
-522
-523
-524
-525
-526
-527
-528
-529
-530
-531
-532
-533
-534
-535
-536
-537
-538
-539
-540
-541
-542
-543
-544
-545
-546
-547
-548
-549
-550
-551
-552
-553
-554
-555
-556
-557
-558
-559
-560
-561
-562
-563
-564
-565
-566
-567
-568
-569
-570
-571
-572
-573
-574
-575
-576
-577
-578
-579
-580
-581
-582
-583
-584
-585
-586
-587
-588
-589
-590
-591
-592
-593
-594
-595
-596
-597
-598
-599
-600
-601
-602
-603
-604
-605
-606
-607
-608
-609
-610
-611
-612
-613
-614
-615
-616
-617
-618
-619
-620
-621
-622
-623
-624
-625
-626
-627
-628
-629
-630
-631
-632
-633
-634
-635
-636
-637
-638
-639
-640
-641
-642
-643
-644
-645
-646
-647
-648
-649
-650
-651
-652
-653
-654
-655
-656
-657
-658
-659
-660
-661
-662
-663
-664
-665
-666
-667
-668
-669
-670
-671
-672
-673
-674
-675
-676
-677
-678
-679
-680
-681
-682
-683
-684
-685
-686
-687
-688
-689
-690
-691
-692
-693
-694
-695
-696
-697
-698
-699
-700
-701
-702
-703
-704
-705
-706
-707
-708
-709
-710
-711
-712
-713
-714
-715
-716
-717
-718
-719
-720
-721
-722
-723
-724
-725
-726
-727
-728
-729
-730
-731
-732
-733
-734
-735
-736
-737
-738
-739
-740
-741
-742
-743
-744
-745
-746
-747
-748
-749
-750
-751
-752
-753
-754
-755
-756
-757
-758
-759
-760
-761
-762
-763
-764
-765
-766
-767
-768
-769
-770
-771
-772
-773
-774
-775
-776
-777
-778
-779
-780
-781
-782
-783
-784
-785
-786
-787
-788
-789
-790
-791
-792
-793
-794
-795
-796
-797
-798
-799
-800
-801
-802
-803
-804
-805
-806
-807
-808
-809
-810
-811
-812
-813
-814
-815
-816
-817
-818
-819
-820
-821
-822
-823
-824
-825
-826
-827
-828
-829
-830
-831
-832
-833
-834
-835
-836
-837
-838
-839
-840
-841
-842
-843
-844
-845
-846
-847
-848
-849
-850
-851
-852
-853
-854
-855
-856
-857
-858
-859
-860
-861
-862
-863
-864
-865
-866
-867
-868
-869
-870
-871
-872
-873
-874
-875
-876
-877
-878
-879
-880
-881
-882
-883
-884
-885
-886
-887
-888
-889
-890
-891
-892
-893
-894
-895
-896
-897
-898
-899
-900
-901
-902
-903
-904
-905
-906
-907
-908
-909
-910
-911
-912
-913
-914
-915
-916
-917
-918
-919
-920
-921
-922
-923
-924
-925
-926
-927
-928
-929
-930
-931
-932
-933
-934
-935
-936
-937
-938
-939
-940
-941
-942
-943
-944
-945
-946
-947
-948
-949
-950
-951
-952
-953
-954
-955
-956
-957
-958
-959
-960
-961
-962
-963
-964
-965
-966
-967
-968
-969
-970
-971
-972
-973
-974
-975
-976
-977
-978
-979
-980
-981
-982
-983
-984
-985
-986
-987
-988
-989
-990
-991
-992
-993
-994
+
   1
+   2
+   3
+   4
+   5
+   6
+   7
+   8
+   9
+  10
+  11
+  12
+  13
+  14
+  15
+  16
+  17
+  18
+  19
+  20
+  21
+  22
+  23
+  24
+  25
+  26
+  27
+  28
+  29
+  30
+  31
+  32
+  33
+  34
+  35
+  36
+  37
+  38
+  39
+  40
+  41
+  42
+  43
+  44
+  45
+  46
+  47
+  48
+  49
+  50
+  51
+  52
+  53
+  54
+  55
+  56
+  57
+  58
+  59
+  60
+  61
+  62
+  63
+  64
+  65
+  66
+  67
+  68
+  69
+  70
+  71
+  72
+  73
+  74
+  75
+  76
+  77
+  78
+  79
+  80
+  81
+  82
+  83
+  84
+  85
+  86
+  87
+  88
+  89
+  90
+  91
+  92
+  93
+  94
+  95
+  96
+  97
+  98
+  99
+ 100
+ 101
+ 102
+ 103
+ 104
+ 105
+ 106
+ 107
+ 108
+ 109
+ 110
+ 111
+ 112
+ 113
+ 114
+ 115
+ 116
+ 117
+ 118
+ 119
+ 120
+ 121
+ 122
+ 123
+ 124
+ 125
+ 126
+ 127
+ 128
+ 129
+ 130
+ 131
+ 132
+ 133
+ 134
+ 135
+ 136
+ 137
+ 138
+ 139
+ 140
+ 141
+ 142
+ 143
+ 144
+ 145
+ 146
+ 147
+ 148
+ 149
+ 150
+ 151
+ 152
+ 153
+ 154
+ 155
+ 156
+ 157
+ 158
+ 159
+ 160
+ 161
+ 162
+ 163
+ 164
+ 165
+ 166
+ 167
+ 168
+ 169
+ 170
+ 171
+ 172
+ 173
+ 174
+ 175
+ 176
+ 177
+ 178
+ 179
+ 180
+ 181
+ 182
+ 183
+ 184
+ 185
+ 186
+ 187
+ 188
+ 189
+ 190
+ 191
+ 192
+ 193
+ 194
+ 195
+ 196
+ 197
+ 198
+ 199
+ 200
+ 201
+ 202
+ 203
+ 204
+ 205
+ 206
+ 207
+ 208
+ 209
+ 210
+ 211
+ 212
+ 213
+ 214
+ 215
+ 216
+ 217
+ 218
+ 219
+ 220
+ 221
+ 222
+ 223
+ 224
+ 225
+ 226
+ 227
+ 228
+ 229
+ 230
+ 231
+ 232
+ 233
+ 234
+ 235
+ 236
+ 237
+ 238
+ 239
+ 240
+ 241
+ 242
+ 243
+ 244
+ 245
+ 246
+ 247
+ 248
+ 249
+ 250
+ 251
+ 252
+ 253
+ 254
+ 255
+ 256
+ 257
+ 258
+ 259
+ 260
+ 261
+ 262
+ 263
+ 264
+ 265
+ 266
+ 267
+ 268
+ 269
+ 270
+ 271
+ 272
+ 273
+ 274
+ 275
+ 276
+ 277
+ 278
+ 279
+ 280
+ 281
+ 282
+ 283
+ 284
+ 285
+ 286
+ 287
+ 288
+ 289
+ 290
+ 291
+ 292
+ 293
+ 294
+ 295
+ 296
+ 297
+ 298
+ 299
+ 300
+ 301
+ 302
+ 303
+ 304
+ 305
+ 306
+ 307
+ 308
+ 309
+ 310
+ 311
+ 312
+ 313
+ 314
+ 315
+ 316
+ 317
+ 318
+ 319
+ 320
+ 321
+ 322
+ 323
+ 324
+ 325
+ 326
+ 327
+ 328
+ 329
+ 330
+ 331
+ 332
+ 333
+ 334
+ 335
+ 336
+ 337
+ 338
+ 339
+ 340
+ 341
+ 342
+ 343
+ 344
+ 345
+ 346
+ 347
+ 348
+ 349
+ 350
+ 351
+ 352
+ 353
+ 354
+ 355
+ 356
+ 357
+ 358
+ 359
+ 360
+ 361
+ 362
+ 363
+ 364
+ 365
+ 366
+ 367
+ 368
+ 369
+ 370
+ 371
+ 372
+ 373
+ 374
+ 375
+ 376
+ 377
+ 378
+ 379
+ 380
+ 381
+ 382
+ 383
+ 384
+ 385
+ 386
+ 387
+ 388
+ 389
+ 390
+ 391
+ 392
+ 393
+ 394
+ 395
+ 396
+ 397
+ 398
+ 399
+ 400
+ 401
+ 402
+ 403
+ 404
+ 405
+ 406
+ 407
+ 408
+ 409
+ 410
+ 411
+ 412
+ 413
+ 414
+ 415
+ 416
+ 417
+ 418
+ 419
+ 420
+ 421
+ 422
+ 423
+ 424
+ 425
+ 426
+ 427
+ 428
+ 429
+ 430
+ 431
+ 432
+ 433
+ 434
+ 435
+ 436
+ 437
+ 438
+ 439
+ 440
+ 441
+ 442
+ 443
+ 444
+ 445
+ 446
+ 447
+ 448
+ 449
+ 450
+ 451
+ 452
+ 453
+ 454
+ 455
+ 456
+ 457
+ 458
+ 459
+ 460
+ 461
+ 462
+ 463
+ 464
+ 465
+ 466
+ 467
+ 468
+ 469
+ 470
+ 471
+ 472
+ 473
+ 474
+ 475
+ 476
+ 477
+ 478
+ 479
+ 480
+ 481
+ 482
+ 483
+ 484
+ 485
+ 486
+ 487
+ 488
+ 489
+ 490
+ 491
+ 492
+ 493
+ 494
+ 495
+ 496
+ 497
+ 498
+ 499
+ 500
+ 501
+ 502
+ 503
+ 504
+ 505
+ 506
+ 507
+ 508
+ 509
+ 510
+ 511
+ 512
+ 513
+ 514
+ 515
+ 516
+ 517
+ 518
+ 519
+ 520
+ 521
+ 522
+ 523
+ 524
+ 525
+ 526
+ 527
+ 528
+ 529
+ 530
+ 531
+ 532
+ 533
+ 534
+ 535
+ 536
+ 537
+ 538
+ 539
+ 540
+ 541
+ 542
+ 543
+ 544
+ 545
+ 546
+ 547
+ 548
+ 549
+ 550
+ 551
+ 552
+ 553
+ 554
+ 555
+ 556
+ 557
+ 558
+ 559
+ 560
+ 561
+ 562
+ 563
+ 564
+ 565
+ 566
+ 567
+ 568
+ 569
+ 570
+ 571
+ 572
+ 573
+ 574
+ 575
+ 576
+ 577
+ 578
+ 579
+ 580
+ 581
+ 582
+ 583
+ 584
+ 585
+ 586
+ 587
+ 588
+ 589
+ 590
+ 591
+ 592
+ 593
+ 594
+ 595
+ 596
+ 597
+ 598
+ 599
+ 600
+ 601
+ 602
+ 603
+ 604
+ 605
+ 606
+ 607
+ 608
+ 609
+ 610
+ 611
+ 612
+ 613
+ 614
+ 615
+ 616
+ 617
+ 618
+ 619
+ 620
+ 621
+ 622
+ 623
+ 624
+ 625
+ 626
+ 627
+ 628
+ 629
+ 630
+ 631
+ 632
+ 633
+ 634
+ 635
+ 636
+ 637
+ 638
+ 639
+ 640
+ 641
+ 642
+ 643
+ 644
+ 645
+ 646
+ 647
+ 648
+ 649
+ 650
+ 651
+ 652
+ 653
+ 654
+ 655
+ 656
+ 657
+ 658
+ 659
+ 660
+ 661
+ 662
+ 663
+ 664
+ 665
+ 666
+ 667
+ 668
+ 669
+ 670
+ 671
+ 672
+ 673
+ 674
+ 675
+ 676
+ 677
+ 678
+ 679
+ 680
+ 681
+ 682
+ 683
+ 684
+ 685
+ 686
+ 687
+ 688
+ 689
+ 690
+ 691
+ 692
+ 693
+ 694
+ 695
+ 696
+ 697
+ 698
+ 699
+ 700
+ 701
+ 702
+ 703
+ 704
+ 705
+ 706
+ 707
+ 708
+ 709
+ 710
+ 711
+ 712
+ 713
+ 714
+ 715
+ 716
+ 717
+ 718
+ 719
+ 720
+ 721
+ 722
+ 723
+ 724
+ 725
+ 726
+ 727
+ 728
+ 729
+ 730
+ 731
+ 732
+ 733
+ 734
+ 735
+ 736
+ 737
+ 738
+ 739
+ 740
+ 741
+ 742
+ 743
+ 744
+ 745
+ 746
+ 747
+ 748
+ 749
+ 750
+ 751
+ 752
+ 753
+ 754
+ 755
+ 756
+ 757
+ 758
+ 759
+ 760
+ 761
+ 762
+ 763
+ 764
+ 765
+ 766
+ 767
+ 768
+ 769
+ 770
+ 771
+ 772
+ 773
+ 774
+ 775
+ 776
+ 777
+ 778
+ 779
+ 780
+ 781
+ 782
+ 783
+ 784
+ 785
+ 786
+ 787
+ 788
+ 789
+ 790
+ 791
+ 792
+ 793
+ 794
+ 795
+ 796
+ 797
+ 798
+ 799
+ 800
+ 801
+ 802
+ 803
+ 804
+ 805
+ 806
+ 807
+ 808
+ 809
+ 810
+ 811
+ 812
+ 813
+ 814
+ 815
+ 816
+ 817
+ 818
+ 819
+ 820
+ 821
+ 822
+ 823
+ 824
+ 825
+ 826
+ 827
+ 828
+ 829
+ 830
+ 831
+ 832
+ 833
+ 834
+ 835
+ 836
+ 837
+ 838
+ 839
+ 840
+ 841
+ 842
+ 843
+ 844
+ 845
+ 846
+ 847
+ 848
+ 849
+ 850
+ 851
+ 852
+ 853
+ 854
+ 855
+ 856
+ 857
+ 858
+ 859
+ 860
+ 861
+ 862
+ 863
+ 864
+ 865
+ 866
+ 867
+ 868
+ 869
+ 870
+ 871
+ 872
+ 873
+ 874
+ 875
+ 876
+ 877
+ 878
+ 879
+ 880
+ 881
+ 882
+ 883
+ 884
+ 885
+ 886
+ 887
+ 888
+ 889
+ 890
+ 891
+ 892
+ 893
+ 894
+ 895
+ 896
+ 897
+ 898
+ 899
+ 900
+ 901
+ 902
+ 903
+ 904
+ 905
+ 906
+ 907
+ 908
+ 909
+ 910
+ 911
+ 912
+ 913
+ 914
+ 915
+ 916
+ 917
+ 918
+ 919
+ 920
+ 921
+ 922
+ 923
+ 924
+ 925
+ 926
+ 927
+ 928
+ 929
+ 930
+ 931
+ 932
+ 933
+ 934
+ 935
+ 936
+ 937
+ 938
+ 939
+ 940
+ 941
+ 942
+ 943
+ 944
+ 945
+ 946
+ 947
+ 948
+ 949
+ 950
+ 951
+ 952
+ 953
+ 954
+ 955
+ 956
+ 957
+ 958
+ 959
+ 960
+ 961
+ 962
+ 963
+ 964
+ 965
+ 966
+ 967
+ 968
+ 969
+ 970
+ 971
+ 972
+ 973
+ 974
+ 975
+ 976
+ 977
+ 978
+ 979
+ 980
+ 981
+ 982
+ 983
+ 984
+ 985
+ 986
+ 987
+ 988
+ 989
+ 990
+ 991
+ 992
+ 993
+ 994
+ 995
+ 996
+ 997
+ 998
+ 999
+1000
 
 //! [![github]](https://github.com/dtolnay/syn)&ensp;[![crates-io]](https://crates.io/crates/syn)&ensp;[![docs-rs]](crate)
 //!
@@ -1248,7 +1254,7 @@
 //!   dynamic library libproc_macro from rustc toolchain.
 
 // Syn types in rustdoc of other crates get linked to here.
-#![doc(html_root_url = "https://docs.rs/syn/1.0.63")]
+#![doc(html_root_url = "https://docs.rs/syn/1.0.73")]
 #![cfg_attr(doc_cfg, feature(doc_cfg))]
 #![allow(non_camel_case_types)]
 // Ignored clippy lints.
@@ -1265,16 +1271,22 @@
     clippy::never_loop,
     clippy::too_many_arguments,
     clippy::trivially_copy_pass_by_ref,
-    clippy::unnecessary_unwrap
+    clippy::unnecessary_unwrap,
+    // clippy bug: https://github.com/rust-lang/rust-clippy/issues/6983
+    clippy::wrong_self_convention
 )]
 // Ignored clippy_pedantic lints.
 #![allow(
     clippy::cast_possible_truncation,
+    // clippy bug: https://github.com/rust-lang/rust-clippy/issues/7127
+    clippy::cloned_instead_of_copied,
     clippy::default_trait_access,
     clippy::empty_enum,
     clippy::expl_impl_clone_on_copy,
     clippy::if_not_else,
     clippy::match_same_arms,
+    // clippy bug: https://github.com/rust-lang/rust-clippy/issues/6984
+    clippy::match_wildcard_for_single_variants,
     clippy::missing_errors_doc,
     clippy::module_name_repetitions,
     clippy::must_use_candidate,
@@ -1991,4 +2003,5 @@
     Ok(file)
 }
 

-

\ No newline at end of file
+
+ \ No newline at end of file diff --git a/src/syn/lifetime.rs.html b/src/syn/lifetime.rs.html index b661ba6..ef155cf 100644 --- a/src/syn/lifetime.rs.html +++ b/src/syn/lifetime.rs.html @@ -1,7 +1,7 @@ -lifetime.rs - source +lifetime.rs - source -
  1
+
  1
   2
   3
   4
@@ -266,7 +266,7 @@
 
 impl Hash for Lifetime {
     fn hash<H: Hasher>(&self, h: &mut H) {
-        self.ident.hash(h)
+        self.ident.hash(h);
     }
 }
 
@@ -311,4 +311,5 @@
     }
 }
 

-

\ No newline at end of file
+
+ \ No newline at end of file diff --git a/src/syn/lit.rs.html b/src/syn/lit.rs.html index 402b3d7..930c310 100644 --- a/src/syn/lit.rs.html +++ b/src/syn/lit.rs.html @@ -1,7 +1,7 @@ -lit.rs - source +lit.rs - source -
   1
+
   1
    2
    3
    4
@@ -1618,7 +1618,7 @@
 
         /// A floating point literal: `1f64` or `1.0e10f64`.
         ///
-        /// Must be finite. May not be infinte or NaN.
+        /// Must be finite. May not be infinite or NaN.
         Float(LitFloat),
 
         /// A boolean literal: `true` or `false`.
@@ -1816,7 +1816,7 @@
     }
 
     pub fn set_span(&mut self, span: Span) {
-        self.repr.token.set_span(span)
+        self.repr.token.set_span(span);
     }
 
     pub fn suffix(&self) -> &str {
@@ -1847,7 +1847,7 @@
     }
 
     pub fn set_span(&mut self, span: Span) {
-        self.repr.token.set_span(span)
+        self.repr.token.set_span(span);
     }
 
     pub fn suffix(&self) -> &str {
@@ -1878,7 +1878,7 @@
     }
 
     pub fn set_span(&mut self, span: Span) {
-        self.repr.token.set_span(span)
+        self.repr.token.set_span(span);
     }
 
     pub fn suffix(&self) -> &str {
@@ -1909,7 +1909,7 @@
     }
 
     pub fn set_span(&mut self, span: Span) {
-        self.repr.token.set_span(span)
+        self.repr.token.set_span(span);
     }
 
     pub fn suffix(&self) -> &str {
@@ -1984,7 +1984,7 @@
     }
 
     pub fn set_span(&mut self, span: Span) {
-        self.repr.token.set_span(span)
+        self.repr.token.set_span(span);
     }
 }
 
@@ -2056,7 +2056,7 @@
     }
 
     pub fn set_span(&mut self, span: Span) {
-        self.repr.token.set_span(span)
+        self.repr.token.set_span(span);
     }
 }
 
@@ -3015,7 +3015,7 @@
         }
 
         let suffix = s;
-        if suffix.is_empty() || crate::ident::xid_ok(&suffix) {
+        if suffix.is_empty() || crate::ident::xid_ok(suffix) {
             let mut repr = value.to_string();
             if negative {
                 repr.insert(0, '-');
@@ -3151,4 +3151,5 @@
     }
 }
 

-

\ No newline at end of file
+
+ \ No newline at end of file diff --git a/src/syn/lookahead.rs.html b/src/syn/lookahead.rs.html index f36b147..fb2c269 100644 --- a/src/syn/lookahead.rs.html +++ b/src/syn/lookahead.rs.html @@ -1,7 +1,7 @@ -lookahead.rs - source +lookahead.rs - source -
  1
+
  1
   2
   3
   4
@@ -335,4 +335,5 @@
 
 impl<F: Copy + FnOnce(TokenMarker) -> T, T: Token> Sealed for F {}
 

-

\ No newline at end of file
+
+ \ No newline at end of file diff --git a/src/syn/mac.rs.html b/src/syn/mac.rs.html index c1ae366..64bbffe 100644 --- a/src/syn/mac.rs.html +++ b/src/syn/mac.rs.html @@ -1,7 +1,7 @@ -mac.rs - source +mac.rs - source -
  1
+
  1
   2
   3
   4
@@ -441,4 +441,5 @@
     }
 }
 

-

\ No newline at end of file
+
+ \ No newline at end of file diff --git a/src/syn/macros.rs.html b/src/syn/macros.rs.html index edbec9d..7817fd3 100644 --- a/src/syn/macros.rs.html +++ b/src/syn/macros.rs.html @@ -1,7 +1,7 @@ -macros.rs - source +macros.rs - source -
  1
+
  1
   2
   3
   4
@@ -339,4 +339,5 @@
     (pub pub) => {};
 }
 

-

\ No newline at end of file
+
+ \ No newline at end of file diff --git a/src/syn/op.rs.html b/src/syn/op.rs.html index c3965e6..9aad523 100644 --- a/src/syn/op.rs.html +++ b/src/syn/op.rs.html @@ -1,7 +1,7 @@ -op.rs - source +op.rs - source -
  1
+
  1
   2
   3
   4
@@ -471,4 +471,5 @@
     }
 }
 

-

\ No newline at end of file
+
+ \ No newline at end of file diff --git a/src/syn/parse.rs.html b/src/syn/parse.rs.html index 7de71b2..b0e5738 100644 --- a/src/syn/parse.rs.html +++ b/src/syn/parse.rs.html @@ -1,7 +1,7 @@ -parse.rs - source +parse.rs - source -
   1
+
   1
    2
    3
    4
@@ -2577,4 +2577,5 @@
     }
 }
 

-

\ No newline at end of file
+
+ \ No newline at end of file diff --git a/src/syn/parse_macro_input.rs.html b/src/syn/parse_macro_input.rs.html index 3295ae1..d38c929 100644 --- a/src/syn/parse_macro_input.rs.html +++ b/src/syn/parse_macro_input.rs.html @@ -1,7 +1,7 @@ -parse_macro_input.rs - source +parse_macro_input.rs - source -
  1
+
  1
   2
   3
   4
@@ -361,4 +361,5 @@
     }
 }
 

-

\ No newline at end of file
+
+ \ No newline at end of file diff --git a/src/syn/parse_quote.rs.html b/src/syn/parse_quote.rs.html index a4eedb8..18f3aaf 100644 --- a/src/syn/parse_quote.rs.html +++ b/src/syn/parse_quote.rs.html @@ -1,7 +1,7 @@ -parse_quote.rs - source +parse_quote.rs - source -
  1
+
  1
   2
   3
   4
@@ -289,4 +289,5 @@
     }
 }
 

-

\ No newline at end of file
+
+ \ No newline at end of file diff --git a/src/syn/path.rs.html b/src/syn/path.rs.html index ab2f3d5..e70c4af 100644 --- a/src/syn/path.rs.html +++ b/src/syn/path.rs.html @@ -1,7 +1,7 @@ -path.rs - source +path.rs - source -
  1
+
  1
   2
   3
   4
@@ -785,6 +785,64 @@
 782
 783
 784
+785
+786
+787
+788
+789
+790
+791
+792
+793
+794
+795
+796
+797
+798
+799
+800
+801
+802
+803
+804
+805
+806
+807
+808
+809
+810
+811
+812
+813
+814
+815
+816
+817
+818
+819
+820
+821
+822
+823
+824
+825
+826
+827
+828
+829
+830
+831
+832
+833
+834
+835
+836
+837
+838
+839
+840
+841
+842
 
 use super::*;
 use crate::punctuated::Punctuated;
@@ -1001,8 +1059,6 @@
 pub mod parsing {
     use super::*;
 
-    #[cfg(feature = "full")]
-    use crate::expr;
     use crate::ext::IdentExt;
     use crate::parse::{Parse, ParseStream, Result};
 
@@ -1031,33 +1087,90 @@
                 }
             }
 
-            if input.peek(Lit) {
-                let lit = input.parse()?;
-                return Ok(GenericArgument::Const(Expr::Lit(lit)));
+            if input.peek(Lit) || input.peek(token::Brace) {
+                return const_argument(input).map(GenericArgument::Const);
             }
 
-            if input.peek(token::Brace) {
-                #[cfg(feature = "full")]
-                {
-                    let block = input.call(expr::parsing::expr_block)?;
-                    return Ok(GenericArgument::Const(Expr::Block(block)));
-                }
+            #[cfg(feature = "full")]
+            let begin = input.fork();
 
-                #[cfg(not(feature = "full"))]
-                {
-                    let begin = input.fork();
-                    let content;
-                    braced!(content in input);
-                    content.parse::<Expr>()?;
+            let argument: Type = input.parse()?;
+
+            #[cfg(feature = "full")]
+            {
+                if match &argument {
+                    Type::Path(argument)
+                        if argument.qself.is_none()
+                            && argument.path.leading_colon.is_none()
+                            && argument.path.segments.len() == 1 =>
+                    {
+                        match argument.path.segments[0].arguments {
+                            PathArguments::AngleBracketed(_) => true,
+                            _ => false,
+                        }
+                    }
+                    _ => false,
+                } && if input.peek(Token![=]) {
+                    input.parse::<Token![=]>()?;
+                    input.parse::<Type>()?;
+                    true
+                } else if input.peek(Token![:]) {
+                    input.parse::<Token![:]>()?;
+                    input.call(constraint_bounds)?;
+                    true
+                } else {
+                    false
+                } {
                     let verbatim = verbatim::between(begin, input);
-                    return Ok(GenericArgument::Const(Expr::Verbatim(verbatim)));
+                    return Ok(GenericArgument::Type(Type::Verbatim(verbatim)));
                 }
             }
 
-            input.parse().map(GenericArgument::Type)
+            Ok(GenericArgument::Type(argument))
         }
     }
 
+    pub fn const_argument(input: ParseStream) -> Result<Expr> {
+        let lookahead = input.lookahead1();
+
+        if input.peek(Lit) {
+            let lit = input.parse()?;
+            return Ok(Expr::Lit(lit));
+        }
+
+        #[cfg(feature = "full")]
+        {
+            if input.peek(Ident) {
+                let ident: Ident = input.parse()?;
+                return Ok(Expr::Path(ExprPath {
+                    attrs: Vec::new(),
+                    qself: None,
+                    path: Path::from(ident),
+                }));
+            }
+        }
+
+        if input.peek(token::Brace) {
+            #[cfg(feature = "full")]
+            {
+                let block: ExprBlock = input.parse()?;
+                return Ok(Expr::Block(block));
+            }
+
+            #[cfg(not(feature = "full"))]
+            {
+                let begin = input.fork();
+                let content;
+                braced!(content in input);
+                content.parse::<Expr>()?;
+                let verbatim = verbatim::between(begin, input);
+                return Ok(Expr::Verbatim(verbatim));
+            }
+        }
+
+        Err(lookahead.error())
+    }
+
     #[cfg_attr(doc_cfg, doc(cfg(feature = "parsing")))]
     impl Parse for AngleBracketedGenericArguments {
         fn parse(input: ParseStream) -> Result<Self> {
@@ -1148,26 +1261,29 @@
             Ok(Constraint {
                 ident: input.parse()?,
                 colon_token: input.parse()?,
-                bounds: {
-                    let mut bounds = Punctuated::new();
-                    loop {
-                        if input.peek(Token![,]) || input.peek(Token![>]) {
-                            break;
-                        }
-                        let value = input.parse()?;
-                        bounds.push_value(value);
-                        if !input.peek(Token![+]) {
-                            break;
-                        }
-                        let punct = input.parse()?;
-                        bounds.push_punct(punct);
-                    }
-                    bounds
-                },
+                bounds: constraint_bounds(input)?,
             })
         }
     }
 
+    #[cfg(feature = "full")]
+    fn constraint_bounds(input: ParseStream) -> Result<Punctuated<TypeParamBound, Token![+]>> {
+        let mut bounds = Punctuated::new();
+        loop {
+            if input.peek(Token![,]) || input.peek(Token![>]) {
+                break;
+            }
+            let value = input.parse()?;
+            bounds.push_value(value);
+            if !input.peek(Token![+]) {
+                break;
+            }
+            let punct = input.parse()?;
+            bounds.push_punct(punct);
+        }
+        Ok(bounds)
+    }
+
     impl Path {
         /// Parse a `Path` containing no path arguments on any of its segments.
         ///
@@ -1571,4 +1687,5 @@
     }
 }
 

-

\ No newline at end of file
+
+ \ No newline at end of file diff --git a/src/syn/print.rs.html b/src/syn/print.rs.html index 64a5066..a02c1dd 100644 --- a/src/syn/print.rs.html +++ b/src/syn/print.rs.html @@ -1,7 +1,7 @@ -print.rs - source +print.rs - source -
 1
+
 1
  2
  3
  4
@@ -35,4 +35,5 @@
     }
 }
 

-

\ No newline at end of file
+
+ \ No newline at end of file diff --git a/src/syn/punctuated.rs.html b/src/syn/punctuated.rs.html index 80a2921..9e81c7d 100644 --- a/src/syn/punctuated.rs.html +++ b/src/syn/punctuated.rs.html @@ -1,7 +1,7 @@ -punctuated.rs - source +punctuated.rs - source -
   1
+
   1
    2
    3
    4
@@ -2061,7 +2061,7 @@
         P: ToTokens,
     {
         fn to_tokens(&self, tokens: &mut TokenStream) {
-            tokens.append_all(self.pairs())
+            tokens.append_all(self.pairs());
         }
     }
 
@@ -2083,4 +2083,5 @@
     }
 }
 

-

\ No newline at end of file
+
+ \ No newline at end of file diff --git a/src/syn/sealed.rs.html b/src/syn/sealed.rs.html index 48de812..6424b75 100644 --- a/src/syn/sealed.rs.html +++ b/src/syn/sealed.rs.html @@ -1,7 +1,7 @@ -sealed.rs - source +sealed.rs - source -
1
+
1
 2
 3
 4
@@ -11,4 +11,5 @@
     pub trait Sealed: Copy {}
 }
 

-

\ No newline at end of file
+
+ \ No newline at end of file diff --git a/src/syn/span.rs.html b/src/syn/span.rs.html index 32dd626..7e19d58 100644 --- a/src/syn/span.rs.html +++ b/src/syn/span.rs.html @@ -1,7 +1,7 @@ -span.rs - source +span.rs - source -
 1
+
 1
  2
  3
  4
@@ -137,4 +137,5 @@
     }
 }
 

-

\ No newline at end of file
+
+ \ No newline at end of file diff --git a/src/syn/spanned.rs.html b/src/syn/spanned.rs.html index 98d4b0a..37279ae 100644 --- a/src/syn/spanned.rs.html +++ b/src/syn/spanned.rs.html @@ -1,7 +1,7 @@ -spanned.rs - source +spanned.rs - source -
  1
+
  1
   2
   3
   4
@@ -231,4 +231,5 @@
     }
 }
 

-

\ No newline at end of file
+
+ \ No newline at end of file diff --git a/src/syn/thread.rs.html b/src/syn/thread.rs.html index 6bc2d8d..910d584 100644 --- a/src/syn/thread.rs.html +++ b/src/syn/thread.rs.html @@ -1,7 +1,7 @@ -thread.rs - source +thread.rs - source -
 1
+
 1
  2
  3
  4
@@ -85,4 +85,5 @@
     }
 }
 

-

\ No newline at end of file
+
+ \ No newline at end of file diff --git a/src/syn/token.rs.html b/src/syn/token.rs.html index c89deef..0c3215a 100644 --- a/src/syn/token.rs.html +++ b/src/syn/token.rs.html @@ -1,7 +1,7 @@ -token.rs - source +token.rs - source -
   1
+
   1
    2
    3
    4
@@ -2029,4 +2029,5 @@
     }
 }
 

-

\ No newline at end of file
+
+ \ No newline at end of file diff --git a/src/syn/tt.rs.html b/src/syn/tt.rs.html index b58555e..6422b23 100644 --- a/src/syn/tt.rs.html +++ b/src/syn/tt.rs.html @@ -1,7 +1,7 @@ -tt.rs - source +tt.rs - source -
  1
+
  1
   2
   3
   4
@@ -217,4 +217,5 @@
     }
 }
 

-

\ No newline at end of file
+
+ \ No newline at end of file diff --git a/src/syn/ty.rs.html b/src/syn/ty.rs.html index bf82974..cb2451f 100644 --- a/src/syn/ty.rs.html +++ b/src/syn/ty.rs.html @@ -1,7 +1,7 @@ -ty.rs - source +ty.rs - source -
   1
+
   1
    2
    3
    4
@@ -1245,6 +1245,7 @@
 1242
 1243
 1244
+1245
 
 use super::*;
 use crate::punctuated::Punctuated;
@@ -1589,7 +1590,6 @@
     use crate::parse::{Parse, ParseStream, Result};
     use crate::path;
     use proc_macro2::{Punct, Spacing, TokenTree};
-    use std::iter::FromIterator;
 
     #[cfg_attr(doc_cfg, doc(cfg(feature = "parsing")))]
     impl Parse for Type {
@@ -2257,12 +2257,14 @@
                     TokenTree::Punct(Punct::new('.', Spacing::Joint)),
                     TokenTree::Punct(Punct::new('.', Spacing::Alone)),
                 ];
-                let tokens = TokenStream::from_iter(args.into_iter().zip(&dot3.spans).map(
-                    |(mut arg, span)| {
+                let tokens: TokenStream = args
+                    .into_iter()
+                    .zip(&dot3.spans)
+                    .map(|(mut arg, span)| {
                         arg.set_span(*span);
                         arg
-                    },
-                ));
+                    })
+                    .collect();
                 Type::Verbatim(tokens)
             } else if allow_mut_self && input.peek(Token![mut]) && input.peek2(Token![self]) {
                 has_mut_self = true;
@@ -2491,4 +2493,5 @@
     }
 }
 

-

\ No newline at end of file
+
+ \ No newline at end of file diff --git a/src/syn/verbatim.rs.html b/src/syn/verbatim.rs.html index 685f058..d0ecf50 100644 --- a/src/syn/verbatim.rs.html +++ b/src/syn/verbatim.rs.html @@ -1,7 +1,7 @@ -verbatim.rs - source +verbatim.rs - source -
 1
+
 1
  2
  3
  4
@@ -33,4 +33,5 @@
     tokens
 }
 

-

\ No newline at end of file
+
+ \ No newline at end of file diff --git a/src/synstructure/lib.rs.html b/src/synstructure/lib.rs.html index f1e8680..e6f9772 100644 --- a/src/synstructure/lib.rs.html +++ b/src/synstructure/lib.rs.html @@ -1,7 +1,7 @@ -lib.rs - source +lib.rs - source -
   1
+
   1
    2
    3
    4
@@ -4887,4 +4887,5 @@
     }
 }
 

-

\ No newline at end of file
+
+ \ No newline at end of file diff --git a/src/synstructure/macros.rs.html b/src/synstructure/macros.rs.html index 86e9fce..9257db1 100644 --- a/src/synstructure/macros.rs.html +++ b/src/synstructure/macros.rs.html @@ -1,7 +1,7 @@ -macros.rs - source +macros.rs - source -
  1
+
  1
   2
   3
   4
@@ -503,4 +503,5 @@ got:
     };
 }
 

-

\ No newline at end of file
+
+ \ No newline at end of file diff --git a/src/unicode_xid/lib.rs.html b/src/unicode_xid/lib.rs.html index 4a3a868..6500f0c 100644 --- a/src/unicode_xid/lib.rs.html +++ b/src/unicode_xid/lib.rs.html @@ -1,5 +1,5 @@ -lib.rs - source
 1
+lib.rs - source
 1
  2
  3
  4
@@ -83,6 +83,14 @@
 82
 83
 84
+85
+86
+87
+88
+89
+90
+91
+92
 
 // Copyright 2012-2015 The Rust Project Developers. See the COPYRIGHT
 // file at the top-level directory of this distribution and at
@@ -160,13 +168,22 @@
 impl UnicodeXID for char {
     #[inline]
     fn is_xid_start(self) -> bool {
-        derived_property::XID_Start(self)
+        // Fast-path for ascii idents
+        ('a' <= self && self <= 'z')
+            || ('A' <= self && self <= 'Z')
+            || (self > '\x7f' && derived_property::XID_Start(self))
     }
 
     #[inline]
     fn is_xid_continue(self) -> bool {
-        derived_property::XID_Continue(self)
+        // Fast-path for ascii idents
+        ('a' <= self && self <= 'z')
+            || ('A' <= self && self <= 'Z')
+            || ('0' <= self && self <= '9')
+            || self == '_'
+            || (self > '\x7f' && derived_property::XID_Continue(self))
     }
 }
 

-

\ No newline at end of file
+
+ \ No newline at end of file diff --git a/src/unicode_xid/tables.rs.html b/src/unicode_xid/tables.rs.html index 3ad957b..218e016 100644 --- a/src/unicode_xid/tables.rs.html +++ b/src/unicode_xid/tables.rs.html @@ -1,5 +1,5 @@ -tables.rs - source
   1
+tables.rs - source
   1
    2
    3
    4
@@ -2839,4 +2839,5 @@
     }
 }
 

-

\ No newline at end of file
+
+ \ No newline at end of file diff --git a/storage.js b/storage.js index 318275e..7737953 100644 --- a/storage.js +++ b/storage.js @@ -1 +1 @@ -var resourcesSuffix="";var darkThemes=["dark","ayu"];var currentTheme=document.getElementById("themeStyle");var mainTheme=document.getElementById("mainThemeStyle");var settingsDataset=(function(){var settingsElement=document.getElementById("default-settings");if(settingsElement===null){return null}var dataset=settingsElement.dataset;if(dataset===undefined){return null}return dataset})();function getSettingValue(settingName){var current=getCurrentValue('rustdoc-'+settingName);if(current!==null){return current}if(settingsDataset!==null){var def=settingsDataset[settingName.replace(/-/g,'_')];if(def!==undefined){return def}}return null}var localStoredTheme=getSettingValue("theme");var savedHref=[];function hasClass(elem,className){return elem&&elem.classList&&elem.classList.contains(className)}function addClass(elem,className){if(!elem||!elem.classList){return}elem.classList.add(className)}function removeClass(elem,className){if(!elem||!elem.classList){return}elem.classList.remove(className)}function onEach(arr,func,reversed){if(arr&&arr.length>0&&func){var length=arr.length;var i;if(reversed!==true){for(i=0;i=0;--i){if(func(arr[i])===true){return true}}}}return false}function onEachLazy(lazyArray,func,reversed){return onEach(Array.prototype.slice.call(lazyArray),func,reversed)}function hasOwnProperty(obj,property){return Object.prototype.hasOwnProperty.call(obj,property)}function usableLocalStorage(){if(typeof Storage==="undefined"){return false}try{return window.localStorage!==null&&window.localStorage!==undefined}catch(err){return false}}function updateLocalStorage(name,value){if(usableLocalStorage()){localStorage[name]=value}else{}}function getCurrentValue(name){if(usableLocalStorage()&&localStorage[name]!==undefined){return localStorage[name]}return null}function switchTheme(styleElem,mainStyleElem,newTheme,saveTheme){var fullBasicCss="rustdoc"+resourcesSuffix+".css";var fullNewTheme=newTheme+resourcesSuffix+".css";var newHref=mainStyleElem.href.replace(fullBasicCss,fullNewTheme);if(saveTheme===true){updateLocalStorage("rustdoc-theme",newTheme)}if(styleElem.href===newHref){return}var found=false;if(savedHref.length===0){onEachLazy(document.getElementsByTagName("link"),function(el){savedHref.push(el.href)})}onEach(savedHref,function(el){if(el===newHref){found=true;return true}});if(found===true){styleElem.href=newHref}}function useSystemTheme(value){if(value===undefined){value=true}updateLocalStorage("rustdoc-use-system-theme",value);var toggle=document.getElementById("use-system-theme");if(toggle&&toggle instanceof HTMLInputElement){toggle.checked=value}}var updateSystemTheme=(function(){if(!window.matchMedia){return function(){let cssTheme=getComputedStyle(document.documentElement).getPropertyValue('content');switchTheme(currentTheme,mainTheme,JSON.parse(cssTheme)||light,true)}}var mql=window.matchMedia("(prefers-color-scheme: dark)");function handlePreferenceChange(mql){if(getSettingValue("use-system-theme")!=="false"){var lightTheme=getSettingValue("preferred-light-theme")||"light";var darkTheme=getSettingValue("preferred-dark-theme")||"dark";if(mql.matches){switchTheme(currentTheme,mainTheme,darkTheme,true)}else{switchTheme(currentTheme,mainTheme,lightTheme,true)}}}mql.addListener(handlePreferenceChange);return function(){handlePreferenceChange(mql)}})();if(getSettingValue("use-system-theme")!=="false"&&window.matchMedia){if(getSettingValue("use-system-theme")===null&&getSettingValue("preferred-dark-theme")===null&&darkThemes.indexOf(localStoredTheme)>=0){updateLocalStorage("rustdoc-preferred-dark-theme",localStoredTheme)}updateSystemTheme()}else{switchTheme(currentTheme,mainTheme,getSettingValue("theme")||"light",false)} \ No newline at end of file +var resourcesSuffix="";var darkThemes=["dark","ayu"];var currentTheme=document.getElementById("themeStyle");var mainTheme=document.getElementById("mainThemeStyle");var settingsDataset=(function(){var settingsElement=document.getElementById("default-settings");if(settingsElement===null){return null}var dataset=settingsElement.dataset;if(dataset===undefined){return null}return dataset})();function getSettingValue(settingName){var current=getCurrentValue('rustdoc-'+settingName);if(current!==null){return current}if(settingsDataset!==null){var def=settingsDataset[settingName.replace(/-/g,'_')];if(def!==undefined){return def}}return null}var localStoredTheme=getSettingValue("theme");var savedHref=[];function hasClass(elem,className){return elem&&elem.classList&&elem.classList.contains(className)}function addClass(elem,className){if(!elem||!elem.classList){return}elem.classList.add(className)}function removeClass(elem,className){if(!elem||!elem.classList){return}elem.classList.remove(className)}function onEach(arr,func,reversed){if(arr&&arr.length>0&&func){var length=arr.length;var i;if(reversed!==true){for(i=0;i=0;--i){if(func(arr[i])===true){return true}}}}return false}function onEachLazy(lazyArray,func,reversed){return onEach(Array.prototype.slice.call(lazyArray),func,reversed)}function hasOwnProperty(obj,property){return Object.prototype.hasOwnProperty.call(obj,property)}function updateLocalStorage(name,value){try{window.localStorage.setItem(name,value)}catch(e){}}function getCurrentValue(name){try{return window.localStorage.getItem(name)}catch(e){return null}}function switchTheme(styleElem,mainStyleElem,newTheme,saveTheme){var fullBasicCss="rustdoc"+resourcesSuffix+".css";var fullNewTheme=newTheme+resourcesSuffix+".css";var newHref=mainStyleElem.href.replace(fullBasicCss,fullNewTheme);if(saveTheme===true){updateLocalStorage("rustdoc-theme",newTheme)}if(styleElem.href===newHref){return}var found=false;if(savedHref.length===0){onEachLazy(document.getElementsByTagName("link"),function(el){savedHref.push(el.href)})}onEach(savedHref,function(el){if(el===newHref){found=true;return true}});if(found===true){styleElem.href=newHref}}function useSystemTheme(value){if(value===undefined){value=true}updateLocalStorage("rustdoc-use-system-theme",value);var toggle=document.getElementById("use-system-theme");if(toggle&&toggle instanceof HTMLInputElement){toggle.checked=value}}var updateSystemTheme=(function(){if(!window.matchMedia){return function(){var cssTheme=getComputedStyle(document.documentElement).getPropertyValue('content');switchTheme(currentTheme,mainTheme,JSON.parse(cssTheme)||"light",true)}}var mql=window.matchMedia("(prefers-color-scheme: dark)");function handlePreferenceChange(mql){if(getSettingValue("use-system-theme")!=="false"){var lightTheme=getSettingValue("preferred-light-theme")||"light";var darkTheme=getSettingValue("preferred-dark-theme")||"dark";if(mql.matches){switchTheme(currentTheme,mainTheme,darkTheme,true)}else{switchTheme(currentTheme,mainTheme,lightTheme,true)}}}mql.addListener(handlePreferenceChange);return function(){handlePreferenceChange(mql)}})();if(getSettingValue("use-system-theme")!=="false"&&window.matchMedia){if(getSettingValue("use-system-theme")===null&&getSettingValue("preferred-dark-theme")===null&&darkThemes.indexOf(localStoredTheme)>=0){updateLocalStorage("rustdoc-preferred-dark-theme",localStoredTheme)}updateSystemTheme()}else{switchTheme(currentTheme,mainTheme,getSettingValue("theme")||"light",false)} \ No newline at end of file diff --git a/syn/all.html b/syn/all.html index 50c61dd..6baa0c5 100644 --- a/syn/all.html +++ b/syn/all.html @@ -1,6 +1,7 @@ -List of all items in this crate +List of all items in this crate -

[−] +

List of all items[−] - List of all items

Structs

Enums

Traits

Macros

Functions

Typedefs

\ No newline at end of file +

Structs

Enums

Traits

Macros

Functions

Typedefs

+ \ No newline at end of file diff --git a/syn/buffer/index.html b/syn/buffer/index.html index d72f546..a0c9b5a 100644 --- a/syn/buffer/index.html +++ b/syn/buffer/index.html @@ -1,7 +1,7 @@ -syn::buffer - Rust +syn::buffer - Rust -

[−][src]Module syn::buffer

A stably addressed token buffer supporting efficient traversal based on a +

Module syn::buffer[−][src]

A stably addressed token buffer supporting efficient traversal based on a cheaply copyable cursor.

This module is available only if Syn is built with the "parsing" feature.

Structs

@@ -9,4 +9,5 @@ cheaply copyable cursor.

TokenBuffer

A buffer that can be efficiently traversed multiple times, unlike TokenStream which requires a deep copy in order to traverse more than once.

-
\ No newline at end of file +
+ \ No newline at end of file diff --git a/syn/buffer/struct.Cursor.html b/syn/buffer/struct.Cursor.html index 5b15164..847bc5f 100644 --- a/syn/buffer/struct.Cursor.html +++ b/syn/buffer/struct.Cursor.html @@ -1,7 +1,7 @@ -syn::buffer::Cursor - Rust +syn::buffer::Cursor - Rust -

[−][src]Struct syn::buffer::Cursor

pub struct Cursor<'a> { /* fields omitted */ }

A cheaply copyable cursor into a TokenBuffer.

+

Struct syn::buffer::Cursor[−][src]

pub struct Cursor<'a> { /* fields omitted */ }

A cheaply copyable cursor into a TokenBuffer.

This cursor holds a shared reference into the immutable data which is used internally to represent a TokenStream, and can be efficiently manipulated and copied around.

@@ -33,21 +33,22 @@ will return a Group(None, ..) if the cursor is looking at one.

pub fn span(self) -> Span[src]

Returns the Span of the current token, or Span::call_site() if this cursor points to eof.

Trait Implementations

impl<'a> Clone for Cursor<'a>[src]

impl<'a> Copy for Cursor<'a>[src]

impl<'a> Eq for Cursor<'a>[src]

impl<'a> PartialEq<Cursor<'a>> for Cursor<'a>[src]

Auto Trait Implementations

impl<'a> RefUnwindSafe for Cursor<'a>[src]

impl<'a> !Send for Cursor<'a>[src]

impl<'a> !Sync for Cursor<'a>[src]

impl<'a> Unpin for Cursor<'a>[src]

impl<'a> UnwindSafe for Cursor<'a>[src]

Blanket Implementations

impl<T> Any for T where
    T: 'static + ?Sized, [src]

impl<T> Borrow<T> for T where
    T: ?Sized, [src]

impl<T> BorrowMut<T> for T where
    T: ?Sized, [src]

impl<T> From<T> for T[src]

impl<T, U> Into<U> for T where
    U: From<T>, [src]

impl<T> ToOwned for T where
    T: Clone, [src]

type Owned = T

The resulting type after obtaining ownership.

-

Auto Trait Implementations

impl<'a> RefUnwindSafe for Cursor<'a>

impl<'a> !Send for Cursor<'a>

impl<'a> !Sync for Cursor<'a>

impl<'a> Unpin for Cursor<'a>

impl<'a> UnwindSafe for Cursor<'a>

Blanket Implementations

impl<T> Any for T where
    T: 'static + ?Sized, [src]

impl<T> Borrow<T> for T where
    T: ?Sized, [src]

impl<T> BorrowMut<T> for T where
    T: ?Sized, [src]

impl<T> From<T> for T[src]

impl<T, U> Into<U> for T where
    U: From<T>, [src]

impl<T> ToOwned for T where
    T: Clone, [src]

type Owned = T

The resulting type after obtaining ownership.

+

impl<T, U> TryFrom<U> for T where
    U: Into<T>, [src]

type Error = Infallible

The type returned in the event of a conversion error.

-

impl<T, U> TryInto<U> for T where
    U: TryFrom<T>, [src]

type Error = <U as TryFrom<T>>::Error

The type returned in the event of a conversion error.

-
\ No newline at end of file +

impl<T, U> TryFrom<U> for T where
    U: Into<T>, [src]

type Error = Infallible

The type returned in the event of a conversion error.

+

impl<T, U> TryInto<U> for T where
    U: TryFrom<T>, [src]

type Error = <U as TryFrom<T>>::Error

The type returned in the event of a conversion error.

+
+ \ No newline at end of file diff --git a/syn/buffer/struct.TokenBuffer.html b/syn/buffer/struct.TokenBuffer.html index 8c7ac08..2e0b77a 100644 --- a/syn/buffer/struct.TokenBuffer.html +++ b/syn/buffer/struct.TokenBuffer.html @@ -1,7 +1,7 @@ -syn::buffer::TokenBuffer - Rust +syn::buffer::TokenBuffer - Rust -

[−][src]Struct syn::buffer::TokenBuffer

pub struct TokenBuffer { /* fields omitted */ }

A buffer that can be efficiently traversed multiple times, unlike +

Struct syn::buffer::TokenBuffer[−][src]

pub struct TokenBuffer { /* fields omitted */ }

A buffer that can be efficiently traversed multiple times, unlike TokenStream which requires a deep copy in order to traverse more than once.

This type is available only if Syn is built with the "parsing" feature.

@@ -13,13 +13,14 @@ once.

TokenStream.

pub fn begin(&self) -> Cursor<'_>[src]

Creates a cursor referencing the first token in the buffer and able to traverse until the end of the buffer.

-

Auto Trait Implementations

Blanket Implementations

impl<T> Any for T where
    T: 'static + ?Sized, [src]

impl<T> Borrow<T> for T where
    T: ?Sized, [src]

impl<T> BorrowMut<T> for T where
    T: ?Sized, [src]

impl<T> From<T> for T[src]

impl<T, U> Into<U> for T where
    U: From<T>, [src]

impl<T, U> TryFrom<U> for T where
    U: Into<T>, [src]

type Error = Infallible

The type returned in the event of a conversion error.

-

impl<T, U> TryInto<U> for T where
    U: TryFrom<T>, [src]

type Error = <U as TryFrom<T>>::Error

The type returned in the event of a conversion error.

-
\ No newline at end of file +

Auto Trait Implementations

Blanket Implementations

impl<T> Any for T where
    T: 'static + ?Sized, [src]

impl<T> Borrow<T> for T where
    T: ?Sized, [src]

impl<T> BorrowMut<T> for T where
    T: ?Sized, [src]

impl<T> From<T> for T[src]

impl<T, U> Into<U> for T where
    U: From<T>, [src]

impl<T, U> TryFrom<U> for T where
    U: Into<T>, [src]

type Error = Infallible

The type returned in the event of a conversion error.

+

impl<T, U> TryInto<U> for T where
    U: TryFrom<T>, [src]

type Error = <U as TryFrom<T>>::Error

The type returned in the event of a conversion error.

+
+ \ No newline at end of file diff --git a/syn/enum.AttrStyle.html b/syn/enum.AttrStyle.html index c9e6882..467ab5f 100644 --- a/syn/enum.AttrStyle.html +++ b/syn/enum.AttrStyle.html @@ -1,7 +1,7 @@ -syn::AttrStyle - Rust +syn::AttrStyle - Rust -

[−][src]Enum syn::AttrStyle

pub enum AttrStyle {
+
Enum syn::AttrStyle[−][src]
pub enum AttrStyle {
     Outer,
     Inner(Bang),
 }
Distinguishes between attributes that decorate an item and attributes
@@ -23,24 +23,25 @@ feature.

 

                    Variants

 
Outer
Inner(Bang)
Trait Implementations
impl Clone for AttrStyle[src]
impl Copy for AttrStyle[src]
impl Debug for AttrStyle[src]
impl Eq for AttrStyle[src]
impl Hash for AttrStyle[src]
impl PartialEq<AttrStyle> for AttrStyle[src]
Auto Trait Implementations
Blanket Implementations
impl<T> Any for T where
    T: 'static + ?Sized, [src]
impl<T> Borrow<T> for T where
    T: ?Sized, [src]
impl<T> BorrowMut<T> for T where
    T: ?Sized, [src]
impl<T> From<T> for T[src]
impl<T, U> Into<U> for T where
    U: From<T>, [src]
impl<T> ToOwned for T where
    T: Clone, [src]
type Owned = T
The resulting type after obtaining ownership.

-
Auto Trait Implementations
Blanket Implementations
impl<T> Any for T where
    T: 'static + ?Sized, [src]
impl<T> Borrow<T> for T where
    T: ?Sized, [src]
impl<T> BorrowMut<T> for T where
    T: ?Sized, [src]
impl<T> From<T> for T[src]
impl<T, U> Into<U> for T where
    U: From<T>, [src]
impl<T> ToOwned for T where
    T: Clone, [src]
type Owned = T
The resulting type after obtaining ownership.

+
impl<T, U> TryFrom<U> for T where
    U: Into<T>, [src]
type Error = Infallible
The type returned in the event of a conversion error.

-
impl<T, U> TryInto<U> for T where
    U: TryFrom<T>, [src]
type Error = <U as TryFrom<T>>::Error
The type returned in the event of a conversion error.

-

\ No newline at end of file
+

impl<T, U> TryFrom<U> for T where
    U: Into<T>, [src]

type Error = Infallible

The type returned in the event of a conversion error.

+

impl<T, U> TryInto<U> for T where
    U: TryFrom<T>, [src]

type Error = <U as TryFrom<T>>::Error

The type returned in the event of a conversion error.

+
+ \ No newline at end of file diff --git a/syn/enum.BinOp.html b/syn/enum.BinOp.html index 861f9fe..8246c2f 100644 --- a/syn/enum.BinOp.html +++ b/syn/enum.BinOp.html @@ -1,7 +1,7 @@ -syn::BinOp - Rust +syn::BinOp - Rust -

[−][src]Enum syn::BinOp

pub enum BinOp {
+
Enum syn::BinOp[−][src]
pub enum BinOp {
     Add(Add),
     Sub(Sub),
     Mul(Star),
@@ -64,29 +64,30 @@ feature.

 
ShlEq(ShlEq)
The <<= operator

 
ShrEq(ShrEq)
The >>= operator

 
Trait Implementations
impl Clone for BinOp[src]
impl Copy for BinOp[src]
impl Debug for BinOp[src]
impl Eq for BinOp[src]
impl Hash for BinOp[src]
impl Parse for BinOp[src]
impl PartialEq<BinOp> for BinOp[src]
impl ToTokens for BinOp[src]
Auto Trait Implementations
Blanket Implementations
impl<T> Any for T where
    T: 'static + ?Sized, [src]
impl<T> Borrow<T> for T where
    T: ?Sized, [src]
impl<T> BorrowMut<T> for T where
    T: ?Sized, [src]
impl<T> From<T> for T[src]
impl<T, U> Into<U> for T where
    U: From<T>, [src]
Auto Trait Implementations
impl RefUnwindSafe for BinOp
impl !Send for BinOp
impl !Sync for BinOp
impl Unpin for BinOp
impl UnwindSafe for BinOp
Blanket Implementations
impl<T> Any for T where
    T: 'static + ?Sized, [src]
impl<T> Borrow<T> for T where
    T: ?Sized, [src]
impl<T> BorrowMut<T> for T where
    T: ?Sized, [src]
impl<T> From<T> for T[src]
impl<T, U> Into<U> for T where
    U: From<T>, [src]
impl<T> Spanned for T where
    T: Spanned + ?Sized, [src]
impl<T> ToOwned for T where
    T: Clone, [src]
type Owned = T
The resulting type after obtaining ownership.

-
impl<T> ToOwned for T where
    T: Clone, [src]
type Owned = T
The resulting type after obtaining ownership.

+
impl<T, U> TryFrom<U> for T where
    U: Into<T>, [src]
type Error = Infallible
The type returned in the event of a conversion error.

-
impl<T, U> TryInto<U> for T where
    U: TryFrom<T>, [src]
type Error = <U as TryFrom<T>>::Error
The type returned in the event of a conversion error.

-

\ No newline at end of file
+

impl<T, U> TryFrom<U> for T where
    U: Into<T>, [src]

type Error = Infallible

The type returned in the event of a conversion error.

+

impl<T, U> TryInto<U> for T where
    U: TryFrom<T>, [src]

type Error = <U as TryFrom<T>>::Error

The type returned in the event of a conversion error.

+
+ \ No newline at end of file diff --git a/syn/enum.Data.html b/syn/enum.Data.html index 60479ea..87b5bc4 100644 --- a/syn/enum.Data.html +++ b/syn/enum.Data.html @@ -1,7 +1,7 @@ -syn::Data - Rust +syn::Data - Rust -

[−][src]Enum syn::Data

pub enum Data {
+
Enum syn::Data[−][src]
pub enum Data {
     Struct(DataStruct),
     Enum(DataEnum),
     Union(DataUnion),
@@ -15,27 +15,28 @@
 
Enum(DataEnum)
An enum input to a proc_macro_derive macro.

 
Union(DataUnion)
An untagged union input to a proc_macro_derive macro.

 
Trait Implementations
impl Clone for Data[src]
impl Debug for Data[src]
impl Eq for Data[src]
impl From<DataEnum> for Data[src]
impl From<DataStruct> for Data[src]
impl From<DataUnion> for Data[src]
impl Hash for Data[src]
impl PartialEq<Data> for Data[src]
Auto Trait Implementations
Blanket Implementations
impl<T> Any for T where
    T: 'static + ?Sized, [src]
impl<T> Borrow<T> for T where
    T: ?Sized, [src]
impl<T> BorrowMut<T> for T where
    T: ?Sized, [src]
impl<T> From<T> for T[src]
impl<T, U> Into<U> for T where
    U: From<T>, [src]
impl<T> ToOwned for T where
    T: Clone, [src]
type Owned = T
The resulting type after obtaining ownership.

-
Auto Trait Implementations
impl RefUnwindSafe for Data
impl !Send for Data
impl !Sync for Data
impl Unpin for Data
impl UnwindSafe for Data
Blanket Implementations
impl<T> Any for T where
    T: 'static + ?Sized, [src]
impl<T> Borrow<T> for T where
    T: ?Sized, [src]
impl<T> BorrowMut<T> for T where
    T: ?Sized, [src]
impl<T> From<T> for T[src]
impl<T, U> Into<U> for T where
    U: From<T>, [src]
impl<T> ToOwned for T where
    T: Clone, [src]
type Owned = T
The resulting type after obtaining ownership.

+
impl<T, U> TryFrom<U> for T where
    U: Into<T>, [src]
type Error = Infallible
The type returned in the event of a conversion error.

-
impl<T, U> TryInto<U> for T where
    U: TryFrom<T>, [src]
type Error = <U as TryFrom<T>>::Error
The type returned in the event of a conversion error.

-

\ No newline at end of file
+

impl<T, U> TryFrom<U> for T where
    U: Into<T>, [src]

type Error = Infallible

The type returned in the event of a conversion error.

+

impl<T, U> TryInto<U> for T where
    U: TryFrom<T>, [src]

type Error = <U as TryFrom<T>>::Error

The type returned in the event of a conversion error.

+
+ \ No newline at end of file diff --git a/syn/enum.Expr.html b/syn/enum.Expr.html index 7ea16c4..0c10dc0 100644 --- a/syn/enum.Expr.html +++ b/syn/enum.Expr.html @@ -1,7 +1,7 @@ -syn::Expr - Rust +syn::Expr - Rust -

[−][src]Enum syn::Expr

pub enum Expr {
+
Enum syn::Expr[−][src]
pub enum Expr {
     Array(ExprArray),
     Assign(ExprAssign),
     AssignOp(ExprAssignOp),
@@ -45,7 +45,7 @@
     // some variants omitted
 }
A Rust expression.

 
This type is available only if Syn is built with the "derive" or "full"
-feature, but most of the variants are not available unless "full" is enabled.

+feature, but most of the variants are not available unless “full” is enabled.

 
Syntax tree enums

 
This type is a syntax tree enum. In Syn this and other syntax tree enums
 are designed to be traversed using the following rebinding idiom.

@@ -140,7 +140,7 @@ parameters and a qualified self-type.

 
While(ExprWhile)
A while loop: while expr { ... }.

 
Yield(ExprYield)
A yield expression: yield expr.

 
Trait Implementations
impl Clone for Expr[src]
impl Debug for Expr[src]
impl Eq for Expr[src]
impl From<ExprArray> for Expr[src]
impl From<ExprAssign> for Expr[src]
impl From<ExprWhile> for Expr[src]
impl From<ExprYield> for Expr[src]
impl Hash for Expr[src]
impl Parse for Expr[src]
impl PartialEq<Expr> for Expr[src]
impl Parse for Expr[src]
impl PartialEq<Expr> for Expr[src]
impl ToTokens for Expr[src]
Auto Trait Implementations
Blanket Implementations
impl<T> Any for T where
    T: 'static + ?Sized, [src]
impl<T> Borrow<T> for T where
    T: ?Sized, [src]
impl<T> BorrowMut<T> for T where
    T: ?Sized, [src]
impl<T> From<T> for T[src]
impl<T, U> Into<U> for T where
    U: From<T>, [src]
Auto Trait Implementations
impl RefUnwindSafe for Expr
impl !Send for Expr
impl !Sync for Expr
impl Unpin for Expr
impl UnwindSafe for Expr
Blanket Implementations
impl<T> Any for T where
    T: 'static + ?Sized, [src]
impl<T> Borrow<T> for T where
    T: ?Sized, [src]
impl<T> BorrowMut<T> for T where
    T: ?Sized, [src]
impl<T> From<T> for T[src]
impl<T, U> Into<U> for T where
    U: From<T>, [src]
impl<T> Spanned for T where
    T: Spanned + ?Sized, [src]
impl<T> ToOwned for T where
    T: Clone, [src]
type Owned = T
The resulting type after obtaining ownership.

-
impl<T> ToOwned for T where
    T: Clone, [src]
type Owned = T
The resulting type after obtaining ownership.

+
impl<T, U> TryFrom<U> for T where
    U: Into<T>, [src]
type Error = Infallible
The type returned in the event of a conversion error.

-
impl<T, U> TryInto<U> for T where
    U: TryFrom<T>, [src]
type Error = <U as TryFrom<T>>::Error
The type returned in the event of a conversion error.

-

\ No newline at end of file
+

impl<T, U> TryFrom<U> for T where
    U: Into<T>, [src]

type Error = Infallible

The type returned in the event of a conversion error.

+

impl<T, U> TryInto<U> for T where
    U: TryFrom<T>, [src]

type Error = <U as TryFrom<T>>::Error

The type returned in the event of a conversion error.

+
+ \ No newline at end of file diff --git a/syn/enum.Fields.html b/syn/enum.Fields.html index 56de2c3..0d4f874 100644 --- a/syn/enum.Fields.html +++ b/syn/enum.Fields.html @@ -1,7 +1,7 @@ -syn::Fields - Rust +syn::Fields - Rust -

[−][src]Enum syn::Fields

pub enum Fields {
+
Enum syn::Fields[−][src]
pub enum Fields {
     Named(FieldsNamed),
     Unnamed(FieldsUnnamed),
     Unit,
@@ -17,19 +17,19 @@ feature.

 
Unit
Unit struct or unit variant such as None.

 
Implementations
impl Fields[src]
pub fn iter(&self) -> Iter<'_, Field>ⓘ
Notable traits for Iter<'a, T>
impl<'a, T> Iterator for Iter<'a, T>    type Item = &'a T;
[src]
Get an iterator over the borrowed Field items in this object. This
 iterator can be used to iterate over a named or unnamed struct or
-variant's fields uniformly.

+variant’s fields uniformly.

 
pub fn iter_mut(&mut self) -> IterMut<'_, Field>ⓘ
Notable traits for IterMut<'a, T>
impl<'a, T> Iterator for IterMut<'a, T>    type Item = &'a mut T;
[src]
Get an iterator over the mutably borrowed Field items in this
 object. This iterator can be used to iterate over a named or unnamed
-struct or variant's fields uniformly.

+struct or variant’s fields uniformly.

 
pub fn len(&self) -> usize[src]
Returns the number of fields.

 
pub fn is_empty(&self) -> bool[src]
Returns true if there are zero fields.

 
Trait Implementations
impl Clone for Fields[src]
impl Debug for Fields[src]
impl Eq for Fields[src]
impl From<FieldsNamed> for Fields[src]
impl From<FieldsUnnamed> for Fields[src]
impl Hash for Fields[src]
impl IntoIterator for Fields[src]
type Item = Field
The type of the elements being iterated over.

 
type IntoIter = IntoIter<Field>
Which kind of iterator are we turning this into?

 
impl PartialEq<Fields> for Fields[src]
impl ToTokens for Fields[src]
Auto Trait Implementations
Blanket Implementations
impl<T> Any for T where
    T: 'static + ?Sized, [src]
impl<T> Borrow<T> for T where
    T: ?Sized, [src]
impl<T> BorrowMut<T> for T where
    T: ?Sized, [src]
impl<T> From<T> for T[src]
impl<T, U> Into<U> for T where
    U: From<T>, [src]
Auto Trait Implementations
impl RefUnwindSafe for Fields
impl !Send for Fields
impl !Sync for Fields
impl Unpin for Fields
impl UnwindSafe for Fields
Blanket Implementations
impl<T> Any for T where
    T: 'static + ?Sized, [src]
impl<T> Borrow<T> for T where
    T: ?Sized, [src]
impl<T> BorrowMut<T> for T where
    T: ?Sized, [src]
impl<T> From<T> for T[src]
impl<T, U> Into<U> for T where
    U: From<T>, [src]
impl<T> Spanned for T where
    T: Spanned + ?Sized, [src]
impl<T> ToOwned for T where
    T: Clone, [src]
type Owned = T
The resulting type after obtaining ownership.

-
impl<T> ToOwned for T where
    T: Clone, [src]
type Owned = T
The resulting type after obtaining ownership.

+
impl<T, U> TryFrom<U> for T where
    U: Into<T>, [src]
type Error = Infallible
The type returned in the event of a conversion error.

-
impl<T, U> TryInto<U> for T where
    U: TryFrom<T>, [src]
type Error = <U as TryFrom<T>>::Error
The type returned in the event of a conversion error.

-

\ No newline at end of file
+

impl<T, U> TryFrom<U> for T where
    U: Into<T>, [src]

type Error = Infallible

The type returned in the event of a conversion error.

+

impl<T, U> TryInto<U> for T where
    U: TryFrom<T>, [src]

type Error = <U as TryFrom<T>>::Error

The type returned in the event of a conversion error.

+
+ \ No newline at end of file diff --git a/syn/enum.GenericArgument.html b/syn/enum.GenericArgument.html index acad681..9139841 100644 --- a/syn/enum.GenericArgument.html +++ b/syn/enum.GenericArgument.html @@ -1,7 +1,7 @@ -syn::GenericArgument - Rust +syn::GenericArgument - Rust -

[−][src]Enum syn::GenericArgument

pub enum GenericArgument {
+
Enum syn::GenericArgument[−][src]
pub enum GenericArgument {
     Lifetime(Lifetime),
     Type(Type),
     Binding(Binding),
@@ -20,29 +20,30 @@ feature.

 
NOTE: Identity expressions are represented as Type arguments, as
 they are indistinguishable syntactically.

 
Trait Implementations
impl Clone for GenericArgument[src]
impl Debug for GenericArgument[src]
impl Eq for GenericArgument[src]
impl Hash for GenericArgument[src]
impl Parse for GenericArgument[src]
impl PartialEq<GenericArgument> for GenericArgument[src]
impl Parse for GenericArgument[src]
impl PartialEq<GenericArgument> for GenericArgument[src]
impl ToTokens for GenericArgument[src]
Auto Trait Implementations
Blanket Implementations
impl<T> Any for T where
    T: 'static + ?Sized, [src]
impl<T> Borrow<T> for T where
    T: ?Sized, [src]
impl<T> BorrowMut<T> for T where
    T: ?Sized, [src]
impl<T> From<T> for T[src]
impl<T, U> Into<U> for T where
    U: From<T>, [src]
impl ToTokens for GenericArgument[src]
Auto Trait Implementations
Blanket Implementations
impl<T> Any for T where
    T: 'static + ?Sized, [src]
impl<T> Borrow<T> for T where
    T: ?Sized, [src]
impl<T> BorrowMut<T> for T where
    T: ?Sized, [src]
impl<T> From<T> for T[src]
impl<T, U> Into<U> for T where
    U: From<T>, [src]
impl<T> Spanned for T where
    T: Spanned + ?Sized, [src]
impl<T> ToOwned for T where
    T: Clone, [src]
type Owned = T
The resulting type after obtaining ownership.

-
impl<T> ToOwned for T where
    T: Clone, [src]
type Owned = T
The resulting type after obtaining ownership.

+
impl<T, U> TryFrom<U> for T where
    U: Into<T>, [src]
type Error = Infallible
The type returned in the event of a conversion error.

-
impl<T, U> TryInto<U> for T where
    U: TryFrom<T>, [src]
type Error = <U as TryFrom<T>>::Error
The type returned in the event of a conversion error.

-

\ No newline at end of file
+

impl<T, U> TryFrom<U> for T where
    U: Into<T>, [src]

type Error = Infallible

The type returned in the event of a conversion error.

+

impl<T, U> TryInto<U> for T where
    U: TryFrom<T>, [src]

type Error = <U as TryFrom<T>>::Error

The type returned in the event of a conversion error.

+
+ \ No newline at end of file diff --git a/syn/enum.GenericParam.html b/syn/enum.GenericParam.html index 337f104..cb71802 100644 --- a/syn/enum.GenericParam.html +++ b/syn/enum.GenericParam.html @@ -1,7 +1,7 @@ -syn::GenericParam - Rust +syn::GenericParam - Rust -

[−][src]Enum syn::GenericParam

pub enum GenericParam {
+
Enum syn::GenericParam[−][src]
pub enum GenericParam {
     Type(TypeParam),
     Lifetime(LifetimeDef),
     Const(ConstParam),
@@ -17,32 +17,33 @@ feature.

 
Lifetime(LifetimeDef)
A lifetime definition: 'a: 'b + 'c + 'd.

 
Const(ConstParam)
A const generic parameter: const LENGTH: usize.

 
Trait Implementations
impl Clone for GenericParam[src]
impl Debug for GenericParam[src]
impl Eq for GenericParam[src]
impl From<ConstParam> for GenericParam[src]
impl From<LifetimeDef> for GenericParam[src]
impl From<TypeParam> for GenericParam[src]
impl Hash for GenericParam[src]
impl Parse for GenericParam[src]
impl PartialEq<GenericParam> for GenericParam[src]
impl Parse for GenericParam[src]
impl PartialEq<GenericParam> for GenericParam[src]
impl ToTokens for GenericParam[src]
Auto Trait Implementations
Blanket Implementations
impl<T> Any for T where
    T: 'static + ?Sized, [src]
impl<T> Borrow<T> for T where
    T: ?Sized, [src]
impl<T> BorrowMut<T> for T where
    T: ?Sized, [src]
impl<T> From<T> for T[src]
impl<T, U> Into<U> for T where
    U: From<T>, [src]
Auto Trait Implementations
Blanket Implementations
impl<T> Any for T where
    T: 'static + ?Sized, [src]
impl<T> Borrow<T> for T where
    T: ?Sized, [src]
impl<T> BorrowMut<T> for T where
    T: ?Sized, [src]
impl<T> From<T> for T[src]
impl<T, U> Into<U> for T where
    U: From<T>, [src]
impl<T> Spanned for T where
    T: Spanned + ?Sized, [src]
impl<T> ToOwned for T where
    T: Clone, [src]
type Owned = T
The resulting type after obtaining ownership.

-
impl<T> ToOwned for T where
    T: Clone, [src]
type Owned = T
The resulting type after obtaining ownership.

+
impl<T, U> TryFrom<U> for T where
    U: Into<T>, [src]
type Error = Infallible
The type returned in the event of a conversion error.

-
impl<T, U> TryInto<U> for T where
    U: TryFrom<T>, [src]
type Error = <U as TryFrom<T>>::Error
The type returned in the event of a conversion error.

-

\ No newline at end of file
+

impl<T, U> TryFrom<U> for T where
    U: Into<T>, [src]

type Error = Infallible

The type returned in the event of a conversion error.

+

impl<T, U> TryInto<U> for T where
    U: TryFrom<T>, [src]

type Error = <U as TryFrom<T>>::Error

The type returned in the event of a conversion error.

+
+ \ No newline at end of file diff --git a/syn/enum.Lit.html b/syn/enum.Lit.html index 91b4a18..f74c190 100644 --- a/syn/enum.Lit.html +++ b/syn/enum.Lit.html @@ -1,7 +1,7 @@ -syn::Lit - Rust +syn::Lit - Rust -

[−][src]Enum syn::Lit

pub enum Lit {
+
Enum syn::Lit[−][src]
pub enum Lit {
     Str(LitStr),
     ByteStr(LitByteStr),
     Byte(LitByte),
@@ -21,14 +21,14 @@
 
Char(LitChar)
A character literal: 'a'.

 
Int(LitInt)
An integer literal: 1 or 1u16.

 
Float(LitFloat)
A floating point literal: 1f64 or 1.0e10f64.

-
Must be finite. May not be infinte or NaN.

+
Must be finite. May not be infinite or NaN.

 
Bool(LitBool)
A boolean literal: true or false.

 
Verbatim(Literal)
A raw token literal not interpreted by Syn.

 
Implementations
impl Lit[src]
pub fn new(token: Literal) -> Self[src]
Interpret a Syn literal from a proc-macro2 literal.

 
pub fn suffix(&self) -> &str[src]
pub fn span(&self) -> Span[src]
pub fn set_span(&mut self, span: Span)[src]
Trait Implementations
impl Clone for Lit[src]
impl Debug for Lit[src]
impl Eq for Lit[src]
impl From<Lit> for NestedMeta[src]
impl Eq for Lit[src]
impl From<Lit> for NestedMeta[src]
impl From<LitBool> for Lit[src]
impl From<LitByte> for Lit[src]
impl From<LitByteStr> for Lit[src]
impl From<LitInt> for Lit[src]
impl From<LitStr> for Lit[src]
impl Hash for Lit[src]
impl Parse for Lit[src]
impl PartialEq<Lit> for Lit[src]
impl ToTokens for Lit[src]
impl Token for Lit[src]
Auto Trait Implementations
impl RefUnwindSafe for Lit[src]
impl !Send for Lit[src]
impl !Sync for Lit[src]
impl Unpin for Lit[src]
impl UnwindSafe for Lit[src]
Blanket Implementations
impl<T> Any for T where
    T: 'static + ?Sized, [src]
impl<T> Borrow<T> for T where
    T: ?Sized, [src]
impl<T> BorrowMut<T> for T where
    T: ?Sized, [src]
impl<T> From<T> for T[src]
impl<T, U> Into<U> for T where
    U: From<T>, [src]
impl Token for Lit[src]
Auto Trait Implementations
impl RefUnwindSafe for Lit
impl !Send for Lit
impl !Sync for Lit
impl Unpin for Lit
impl UnwindSafe for Lit
Blanket Implementations
impl<T> Any for T where
    T: 'static + ?Sized, [src]
impl<T> Borrow<T> for T where
    T: ?Sized, [src]
impl<T> BorrowMut<T> for T where
    T: ?Sized, [src]
impl<T> From<T> for T[src]
impl<T, U> Into<U> for T where
    U: From<T>, [src]
impl<T> Spanned for T where
    T: Spanned + ?Sized, [src]
impl<T> ToOwned for T where
    T: Clone, [src]
type Owned = T
The resulting type after obtaining ownership.

-
impl<T> ToOwned for T where
    T: Clone, [src]
type Owned = T
The resulting type after obtaining ownership.

+
impl<T, U> TryFrom<U> for T where
    U: Into<T>, [src]
type Error = Infallible
The type returned in the event of a conversion error.

-
impl<T, U> TryInto<U> for T where
    U: TryFrom<T>, [src]
type Error = <U as TryFrom<T>>::Error
The type returned in the event of a conversion error.

-

\ No newline at end of file
+

impl<T, U> TryFrom<U> for T where
    U: Into<T>, [src]

type Error = Infallible

The type returned in the event of a conversion error.

+

impl<T, U> TryInto<U> for T where
    U: TryFrom<T>, [src]

type Error = <U as TryFrom<T>>::Error

The type returned in the event of a conversion error.

+
+ \ No newline at end of file diff --git a/syn/enum.MacroDelimiter.html b/syn/enum.MacroDelimiter.html index a5404cb..355f1d8 100644 --- a/syn/enum.MacroDelimiter.html +++ b/syn/enum.MacroDelimiter.html @@ -1,7 +1,7 @@ -syn::MacroDelimiter - Rust +syn::MacroDelimiter - Rust -

[−][src]Enum syn::MacroDelimiter

pub enum MacroDelimiter {
+
Enum syn::MacroDelimiter[−][src]
pub enum MacroDelimiter {
     Paren(Paren),
     Brace(Brace),
     Bracket(Bracket),
@@ -11,24 +11,25 @@ feature.

 

                    Variants

 
Paren(Paren)
Brace(Brace)
Bracket(Bracket)
Trait Implementations
impl Clone for MacroDelimiter[src]
impl Debug for MacroDelimiter[src]
impl Eq for MacroDelimiter[src]
impl Hash for MacroDelimiter[src]
impl PartialEq<MacroDelimiter> for MacroDelimiter[src]
Auto Trait Implementations
Blanket Implementations
impl<T> Any for T where
    T: 'static + ?Sized, [src]
impl<T> Borrow<T> for T where
    T: ?Sized, [src]
impl<T> BorrowMut<T> for T where
    T: ?Sized, [src]
impl<T> From<T> for T[src]
impl<T, U> Into<U> for T where
    U: From<T>, [src]
impl<T> ToOwned for T where
    T: Clone, [src]
type Owned = T
The resulting type after obtaining ownership.

-
Auto Trait Implementations
Blanket Implementations
impl<T> Any for T where
    T: 'static + ?Sized, [src]
impl<T> Borrow<T> for T where
    T: ?Sized, [src]
impl<T> BorrowMut<T> for T where
    T: ?Sized, [src]
impl<T> From<T> for T[src]
impl<T, U> Into<U> for T where
    U: From<T>, [src]
impl<T> ToOwned for T where
    T: Clone, [src]
type Owned = T
The resulting type after obtaining ownership.

+
impl<T, U> TryFrom<U> for T where
    U: Into<T>, [src]
type Error = Infallible
The type returned in the event of a conversion error.

-
impl<T, U> TryInto<U> for T where
    U: TryFrom<T>, [src]
type Error = <U as TryFrom<T>>::Error
The type returned in the event of a conversion error.

-

\ No newline at end of file
+

impl<T, U> TryFrom<U> for T where
    U: Into<T>, [src]

type Error = Infallible

The type returned in the event of a conversion error.

+

impl<T, U> TryInto<U> for T where
    U: TryFrom<T>, [src]

type Error = <U as TryFrom<T>>::Error

The type returned in the event of a conversion error.

+
+ \ No newline at end of file diff --git a/syn/enum.Member.html b/syn/enum.Member.html index be54f83..0ffdd67 100644 --- a/syn/enum.Member.html +++ b/syn/enum.Member.html @@ -1,7 +1,7 @@ -syn::Member - Rust +syn::Member - Rust -

[−][src]Enum syn::Member

pub enum Member {
+
Enum syn::Member[−][src]
pub enum Member {
     Named(Ident),
     Unnamed(Index),
 }
A struct or tuple struct field accessed in a struct literal or field
@@ -13,31 +13,35 @@ feature.

 
Named(Ident)
A named field like self.x.

 
Unnamed(Index)
An unnamed field like self.0.

 
Trait Implementations
impl Clone for Member[src]
impl Debug for Member[src]
impl Eq for Member[src]
impl Hash for Member[src]
impl IdentFragment for Member[src]
impl Parse for Member[src]
impl PartialEq<Member> for Member[src]
impl Eq for Member[src]
impl From<Ident> for Member[src]
impl From<Index> for Member[src]
impl From<usize> for Member[src]
impl Hash for Member[src]
impl IdentFragment for Member[src]
impl Parse for Member[src]
impl PartialEq<Member> for Member[src]
impl ToTokens for Member[src]
Auto Trait Implementations
Blanket Implementations
impl<T> Any for T where
    T: 'static + ?Sized, [src]
impl<T> Borrow<T> for T where
    T: ?Sized, [src]
impl<T> BorrowMut<T> for T where
    T: ?Sized, [src]
impl<T> From<T> for T[src]
impl<T, U> Into<U> for T where
    U: From<T>, [src]
impl ToTokens for Member[src]
Auto Trait Implementations
impl RefUnwindSafe for Member
impl !Send for Member
impl !Sync for Member
impl Unpin for Member
impl UnwindSafe for Member
Blanket Implementations
impl<T> Any for T where
    T: 'static + ?Sized, [src]
impl<T> Borrow<T> for T where
    T: ?Sized, [src]
impl<T> BorrowMut<T> for T where
    T: ?Sized, [src]
impl<T> From<T> for T[src]
impl<T, U> Into<U> for T where
    U: From<T>, [src]
impl<T> Spanned for T where
    T: Spanned + ?Sized, [src]
impl<T> ToOwned for T where
    T: Clone, [src]
type Owned = T
The resulting type after obtaining ownership.

-
impl<T> ToOwned for T where
    T: Clone, [src]
type Owned = T
The resulting type after obtaining ownership.

+
impl<T, U> TryFrom<U> for T where
    U: Into<T>, [src]
type Error = Infallible
The type returned in the event of a conversion error.

-
impl<T, U> TryInto<U> for T where
    U: TryFrom<T>, [src]
type Error = <U as TryFrom<T>>::Error
The type returned in the event of a conversion error.

-

\ No newline at end of file
+

impl<T, U> TryFrom<U> for T where
    U: Into<T>, [src]

type Error = Infallible

The type returned in the event of a conversion error.

+

impl<T, U> TryInto<U> for T where
    U: TryFrom<T>, [src]

type Error = <U as TryFrom<T>>::Error

The type returned in the event of a conversion error.

+
+ \ No newline at end of file diff --git a/syn/enum.Meta.html b/syn/enum.Meta.html index 6b91072..da2270a 100644 --- a/syn/enum.Meta.html +++ b/syn/enum.Meta.html @@ -1,7 +1,7 @@ -syn::Meta - Rust +syn::Meta - Rust -

[−][src]Enum syn::Meta

pub enum Meta {
+
Enum syn::Meta[−][src]
pub enum Meta {
     Path(Path),
     List(MetaList),
     NameValue(MetaNameValue),
@@ -20,37 +20,38 @@ feature.

                    Variants
 
Path(Path)
List(MetaList)
A structured list within an attribute, like derive(Copy, Clone).

 
NameValue(MetaNameValue)
A name-value pair within an attribute, like feature = "nightly".

-
Implementations
impl Meta[src]
pub fn path(&self) -> &Path[src]
Returns the identifier that begins this structured meta item.

+
Implementations
impl Meta[src]
pub fn path(&self) -> &Path[src]
Returns the identifier that begins this structured meta item.

 
For example this would return the test in #[test], the derive in
 #[derive(Copy)], and the path in #[path = "sys/windows.rs"].

 
Trait Implementations
impl Clone for Meta[src]
impl Debug for Meta[src]
impl Eq for Meta[src]
impl From<Meta> for NestedMeta[src]
impl From<MetaList> for Meta[src]
impl From<MetaNameValue> for Meta[src]
impl From<Path> for Meta[src]
impl Eq for Meta[src]
impl From<Meta> for NestedMeta[src]
impl From<MetaList> for Meta[src]
impl From<MetaNameValue> for Meta[src]
impl From<Path> for Meta[src]
impl Hash for Meta[src]
impl Parse for Meta[src]
impl PartialEq<Meta> for Meta[src]
impl Parse for Meta[src]
impl PartialEq<Meta> for Meta[src]
impl ToTokens for Meta[src]
Auto Trait Implementations
Blanket Implementations
impl<T> Any for T where
    T: 'static + ?Sized, [src]
impl<T> Borrow<T> for T where
    T: ?Sized, [src]
impl<T> BorrowMut<T> for T where
    T: ?Sized, [src]
impl<T> From<T> for T[src]
impl<T, U> Into<U> for T where
    U: From<T>, [src]
impl ToTokens for Meta[src]
Auto Trait Implementations
impl RefUnwindSafe for Meta
impl !Send for Meta
impl !Sync for Meta
impl Unpin for Meta
impl UnwindSafe for Meta
Blanket Implementations
impl<T> Any for T where
    T: 'static + ?Sized, [src]
impl<T> Borrow<T> for T where
    T: ?Sized, [src]
impl<T> BorrowMut<T> for T where
    T: ?Sized, [src]
impl<T> From<T> for T[src]
impl<T, U> Into<U> for T where
    U: From<T>, [src]
impl<T> Spanned for T where
    T: Spanned + ?Sized, [src]
impl<T> ToOwned for T where
    T: Clone, [src]
type Owned = T
The resulting type after obtaining ownership.

-
impl<T> ToOwned for T where
    T: Clone, [src]
type Owned = T
The resulting type after obtaining ownership.

+
impl<T, U> TryFrom<U> for T where
    U: Into<T>, [src]
type Error = Infallible
The type returned in the event of a conversion error.

-
impl<T, U> TryInto<U> for T where
    U: TryFrom<T>, [src]
type Error = <U as TryFrom<T>>::Error
The type returned in the event of a conversion error.

-

\ No newline at end of file
+

impl<T, U> TryFrom<U> for T where
    U: Into<T>, [src]

type Error = Infallible

The type returned in the event of a conversion error.

+

impl<T, U> TryInto<U> for T where
    U: TryFrom<T>, [src]

type Error = <U as TryFrom<T>>::Error

The type returned in the event of a conversion error.

+
+ \ No newline at end of file diff --git a/syn/enum.NestedMeta.html b/syn/enum.NestedMeta.html index 3339bf6..69682bd 100644 --- a/syn/enum.NestedMeta.html +++ b/syn/enum.NestedMeta.html @@ -1,7 +1,7 @@ -syn::NestedMeta - Rust +syn::NestedMeta - Rust -

[−][src]Enum syn::NestedMeta

pub enum NestedMeta {
+
Enum syn::NestedMeta[−][src]
pub enum NestedMeta {
     Meta(Meta),
     Lit(Lit),
 }
Element of a compile-time attribute list.

@@ -13,31 +13,32 @@ feature.

 would be a nested Meta::Path.

 
Lit(Lit)
A Rust literal, like the "new_name" in #[rename("new_name")].

 
Trait Implementations
impl Clone for NestedMeta[src]
impl Debug for NestedMeta[src]
impl Eq for NestedMeta[src]
impl From<Lit> for NestedMeta[src]
impl From<Meta> for NestedMeta[src]
impl Eq for NestedMeta[src]
impl From<Lit> for NestedMeta[src]
impl From<Meta> for NestedMeta[src]
impl Hash for NestedMeta[src]
impl Parse for NestedMeta[src]
impl PartialEq<NestedMeta> for NestedMeta[src]
impl Parse for NestedMeta[src]
impl PartialEq<NestedMeta> for NestedMeta[src]
impl ToTokens for NestedMeta[src]
Auto Trait Implementations
Blanket Implementations
impl<T> Any for T where
    T: 'static + ?Sized, [src]
impl<T> Borrow<T> for T where
    T: ?Sized, [src]
impl<T> BorrowMut<T> for T where
    T: ?Sized, [src]
impl<T> From<T> for T[src]
impl<T, U> Into<U> for T where
    U: From<T>, [src]
impl ToTokens for NestedMeta[src]
Auto Trait Implementations
Blanket Implementations
impl<T> Any for T where
    T: 'static + ?Sized, [src]
impl<T> Borrow<T> for T where
    T: ?Sized, [src]
impl<T> BorrowMut<T> for T where
    T: ?Sized, [src]
impl<T> From<T> for T[src]
impl<T, U> Into<U> for T where
    U: From<T>, [src]
impl<T> Spanned for T where
    T: Spanned + ?Sized, [src]
impl<T> ToOwned for T where
    T: Clone, [src]
type Owned = T
The resulting type after obtaining ownership.

-
impl<T> ToOwned for T where
    T: Clone, [src]
type Owned = T
The resulting type after obtaining ownership.

+
impl<T, U> TryFrom<U> for T where
    U: Into<T>, [src]
type Error = Infallible
The type returned in the event of a conversion error.

-
impl<T, U> TryInto<U> for T where
    U: TryFrom<T>, [src]
type Error = <U as TryFrom<T>>::Error
The type returned in the event of a conversion error.

-

\ No newline at end of file
+

impl<T, U> TryFrom<U> for T where
    U: Into<T>, [src]

type Error = Infallible

The type returned in the event of a conversion error.

+

impl<T, U> TryInto<U> for T where
    U: TryFrom<T>, [src]

type Error = <U as TryFrom<T>>::Error

The type returned in the event of a conversion error.

+
+ \ No newline at end of file diff --git a/syn/enum.PathArguments.html b/syn/enum.PathArguments.html index b5df6de..af08ecb 100644 --- a/syn/enum.PathArguments.html +++ b/syn/enum.PathArguments.html @@ -1,7 +1,7 @@ -syn::PathArguments - Rust +syn::PathArguments - Rust -

[−][src]Enum syn::PathArguments

pub enum PathArguments {
+
Enum syn::PathArguments[−][src]
pub enum PathArguments {
     None,
     AngleBracketed(AngleBracketedGenericArguments),
     Parenthesized(ParenthesizedGenericArguments),
@@ -17,30 +17,31 @@ feature.

 
None
The <'a, T> in std::slice::iter<'a, T>.

 
The (A, B) -> C in Fn(A, B) -> C.

 
Implementations
impl PathArguments[src]
pub fn is_empty(&self) -> bool[src]
Trait Implementations
impl Clone for PathArguments[src]
impl Debug for PathArguments[src]
impl Default for PathArguments[src]
impl Default for PathArguments[src]
impl Eq for PathArguments[src]
impl Hash for PathArguments[src]
impl PartialEq<PathArguments> for PathArguments[src]
impl ToTokens for PathArguments[src]
Auto Trait Implementations
Blanket Implementations
impl<T> Any for T where
    T: 'static + ?Sized, [src]
impl<T> Borrow<T> for T where
    T: ?Sized, [src]
impl<T> BorrowMut<T> for T where
    T: ?Sized, [src]
impl<T> From<T> for T[src]
impl<T, U> Into<U> for T where
    U: From<T>, [src]
impl ToTokens for PathArguments[src]
Auto Trait Implementations
Blanket Implementations
impl<T> Any for T where
    T: 'static + ?Sized, [src]
impl<T> Borrow<T> for T where
    T: ?Sized, [src]
impl<T> BorrowMut<T> for T where
    T: ?Sized, [src]
impl<T> From<T> for T[src]
impl<T, U> Into<U> for T where
    U: From<T>, [src]
impl<T> Spanned for T where
    T: Spanned + ?Sized, [src]
impl<T> ToOwned for T where
    T: Clone, [src]
type Owned = T
The resulting type after obtaining ownership.

-
impl<T> ToOwned for T where
    T: Clone, [src]
type Owned = T
The resulting type after obtaining ownership.

+
impl<T, U> TryFrom<U> for T where
    U: Into<T>, [src]
type Error = Infallible
The type returned in the event of a conversion error.

-
impl<T, U> TryInto<U> for T where
    U: TryFrom<T>, [src]
type Error = <U as TryFrom<T>>::Error
The type returned in the event of a conversion error.

-

\ No newline at end of file
+

impl<T, U> TryFrom<U> for T where
    U: Into<T>, [src]

type Error = Infallible

The type returned in the event of a conversion error.

+

impl<T, U> TryInto<U> for T where
    U: TryFrom<T>, [src]

type Error = <U as TryFrom<T>>::Error

The type returned in the event of a conversion error.

+
+ \ No newline at end of file diff --git a/syn/enum.ReturnType.html b/syn/enum.ReturnType.html index 8e3e9da..ba1ca46 100644 --- a/syn/enum.ReturnType.html +++ b/syn/enum.ReturnType.html @@ -1,7 +1,7 @@ -syn::ReturnType - Rust +syn::ReturnType - Rust -

[−][src]Enum syn::ReturnType

pub enum ReturnType {
+
Enum syn::ReturnType[−][src]
pub enum ReturnType {
     Default,
     Type(RArrow, Box<Type>),
 }
Return type of a function signature.

@@ -12,30 +12,31 @@ feature.

 
Default
Return type is not specified.

 
Functions default to () and closures default to type inference.

 
Type(RArrow, Box<Type>)
A particular type is returned.

-
Implementations
impl ReturnType[src]
pub fn without_plus(input: ParseStream<'_>) -> Result<Self>[src]
Trait Implementations
impl Clone for ReturnType[src]
Implementations
impl ReturnType[src]
pub fn without_plus(input: ParseStream<'_>) -> Result<Self>[src]
Trait Implementations
impl Clone for ReturnType[src]
impl Debug for ReturnType[src]
impl Eq for ReturnType[src]
impl Hash for ReturnType[src]
impl Parse for ReturnType[src]
impl PartialEq<ReturnType> for ReturnType[src]
impl Parse for ReturnType[src]
impl PartialEq<ReturnType> for ReturnType[src]
impl ToTokens for ReturnType[src]
Auto Trait Implementations
Blanket Implementations
impl<T> Any for T where
    T: 'static + ?Sized, [src]
impl<T> Borrow<T> for T where
    T: ?Sized, [src]
impl<T> BorrowMut<T> for T where
    T: ?Sized, [src]
impl<T> From<T> for T[src]
impl<T, U> Into<U> for T where
    U: From<T>, [src]
impl ToTokens for ReturnType[src]
Auto Trait Implementations
Blanket Implementations
impl<T> Any for T where
    T: 'static + ?Sized, [src]
impl<T> Borrow<T> for T where
    T: ?Sized, [src]
impl<T> BorrowMut<T> for T where
    T: ?Sized, [src]
impl<T> From<T> for T[src]
impl<T, U> Into<U> for T where
    U: From<T>, [src]
impl<T> Spanned for T where
    T: Spanned + ?Sized, [src]
impl<T> ToOwned for T where
    T: Clone, [src]
type Owned = T
The resulting type after obtaining ownership.

-
impl<T> ToOwned for T where
    T: Clone, [src]
type Owned = T
The resulting type after obtaining ownership.

+
impl<T, U> TryFrom<U> for T where
    U: Into<T>, [src]
type Error = Infallible
The type returned in the event of a conversion error.

-
impl<T, U> TryInto<U> for T where
    U: TryFrom<T>, [src]
type Error = <U as TryFrom<T>>::Error
The type returned in the event of a conversion error.

-

\ No newline at end of file
+

impl<T, U> TryFrom<U> for T where
    U: Into<T>, [src]

type Error = Infallible

The type returned in the event of a conversion error.

+

impl<T, U> TryInto<U> for T where
    U: TryFrom<T>, [src]

type Error = <U as TryFrom<T>>::Error

The type returned in the event of a conversion error.

+
+ \ No newline at end of file diff --git a/syn/enum.StrStyle.html b/syn/enum.StrStyle.html index 00d9ced..1000a95 100644 --- a/syn/enum.StrStyle.html +++ b/syn/enum.StrStyle.html @@ -1,7 +1,7 @@ -syn::StrStyle - Rust +syn::StrStyle - Rust -

[−][src]Enum syn::StrStyle

pub enum StrStyle {
+
Enum syn::StrStyle[−][src]
pub enum StrStyle {
     Cooked,
     Raw(usize),
 }
The style of a string literal, either plain quoted or a raw string like
@@ -11,13 +11,14 @@
 
Cooked
An ordinary string like "data".

 
Raw(usize)
A raw string like r##"data"##.

 
The unsigned integer is the number of # symbols used.

-
Auto Trait Implementations
Blanket Implementations
impl<T> Any for T where
    T: 'static + ?Sized, [src]
impl<T> Borrow<T> for T where
    T: ?Sized, [src]
impl<T> BorrowMut<T> for T where
    T: ?Sized, [src]
impl<T> From<T> for T[src]
impl<T, U> Into<U> for T where
    U: From<T>, [src]
impl<T, U> TryFrom<U> for T where
    U: Into<T>, [src]
type Error = Infallible
The type returned in the event of a conversion error.

-
impl<T, U> TryInto<U> for T where
    U: TryFrom<T>, [src]
type Error = <U as TryFrom<T>>::Error
The type returned in the event of a conversion error.

-

\ No newline at end of file
+

Auto Trait Implementations

Blanket Implementations

impl<T> Any for T where
    T: 'static + ?Sized, [src]

impl<T> Borrow<T> for T where
    T: ?Sized, [src]

impl<T> BorrowMut<T> for T where
    T: ?Sized, [src]

impl<T> From<T> for T[src]

impl<T, U> Into<U> for T where
    U: From<T>, [src]

impl<T, U> TryFrom<U> for T where
    U: Into<T>, [src]

type Error = Infallible

The type returned in the event of a conversion error.

+

impl<T, U> TryInto<U> for T where
    U: TryFrom<T>, [src]

type Error = <U as TryFrom<T>>::Error

The type returned in the event of a conversion error.

+
+ \ No newline at end of file diff --git a/syn/enum.TraitBoundModifier.html b/syn/enum.TraitBoundModifier.html index e3bc7df..19e3d24 100644 --- a/syn/enum.TraitBoundModifier.html +++ b/syn/enum.TraitBoundModifier.html @@ -1,7 +1,7 @@ -syn::TraitBoundModifier - Rust +syn::TraitBoundModifier - Rust -

[−][src]Enum syn::TraitBoundModifier

pub enum TraitBoundModifier {
+
Enum syn::TraitBoundModifier[−][src]
pub enum TraitBoundModifier {
     None,
     Maybe(Question),
 }
A modifier on a trait bound, currently only used for the ? in
@@ -11,29 +11,30 @@ feature.

 

                    Variants

 
None
Maybe(Question)
Trait Implementations
impl Clone for TraitBoundModifier[src]
impl Copy for TraitBoundModifier[src]
impl Debug for TraitBoundModifier[src]
impl Eq for TraitBoundModifier[src]
impl Hash for TraitBoundModifier[src]
impl Parse for TraitBoundModifier[src]
impl PartialEq<TraitBoundModifier> for TraitBoundModifier[src]
impl Parse for TraitBoundModifier[src]
impl PartialEq<TraitBoundModifier> for TraitBoundModifier[src]
impl ToTokens for TraitBoundModifier[src]
Auto Trait Implementations
Blanket Implementations
impl<T> Any for T where
    T: 'static + ?Sized, [src]
impl<T> Borrow<T> for T where
    T: ?Sized, [src]
impl<T> BorrowMut<T> for T where
    T: ?Sized, [src]
impl<T> From<T> for T[src]
impl<T, U> Into<U> for T where
    U: From<T>, [src]
impl ToTokens for TraitBoundModifier[src]
Auto Trait Implementations
Blanket Implementations
impl<T> Any for T where
    T: 'static + ?Sized, [src]
impl<T> Borrow<T> for T where
    T: ?Sized, [src]
impl<T> BorrowMut<T> for T where
    T: ?Sized, [src]
impl<T> From<T> for T[src]
impl<T, U> Into<U> for T where
    U: From<T>, [src]
impl<T> Spanned for T where
    T: Spanned + ?Sized, [src]
impl<T> ToOwned for T where
    T: Clone, [src]
type Owned = T
The resulting type after obtaining ownership.

-
impl<T> ToOwned for T where
    T: Clone, [src]
type Owned = T
The resulting type after obtaining ownership.

+
impl<T, U> TryFrom<U> for T where
    U: Into<T>, [src]
type Error = Infallible
The type returned in the event of a conversion error.

-
impl<T, U> TryInto<U> for T where
    U: TryFrom<T>, [src]
type Error = <U as TryFrom<T>>::Error
The type returned in the event of a conversion error.

-

\ No newline at end of file
+

impl<T, U> TryFrom<U> for T where
    U: Into<T>, [src]

type Error = Infallible

The type returned in the event of a conversion error.

+

impl<T, U> TryInto<U> for T where
    U: TryFrom<T>, [src]

type Error = <U as TryFrom<T>>::Error

The type returned in the event of a conversion error.

+
+ \ No newline at end of file diff --git a/syn/enum.Type.html b/syn/enum.Type.html index 0b49c80..9857e1e 100644 --- a/syn/enum.Type.html +++ b/syn/enum.Type.html @@ -1,7 +1,7 @@ -syn::Type - Rust +syn::Type - Rust -

[−][src]Enum syn::Type

pub enum Type {
+
Enum syn::Type[−][src]
pub enum Type {
     Array(TypeArray),
     BareFn(TypeBareFn),
     Group(TypeGroup),
@@ -43,12 +43,12 @@ self-type as in <Vec<T> as SomeTrait>::Associated.

 trait or a lifetime.

 
Tuple(TypeTuple)
A tuple type: (A, B, C, String).

 
Verbatim(TokenStream)
Tokens in type position not interpreted by Syn.

-
Implementations
impl Type[src]
pub fn without_plus(input: ParseStream<'_>) -> Result<Self>[src]
In some positions, types may not contain the + character, to
+
Implementations
impl Type[src]
pub fn without_plus(input: ParseStream<'_>) -> Result<Self>[src]
In some positions, types may not contain the + character, to
 disambiguate them. For example in the expression 1 as T, T may not
 contain a + character.

 
This parser does not allow a +, while the default parser does.

 
Trait Implementations
impl Clone for Type[src]
impl Debug for Type[src]
impl Eq for Type[src]
impl From<TypeArray> for Type[src]
impl From<TypeBareFn> for Type[src]
impl From<TypeTraitObject> for Type[src]
impl From<TypeTuple> for Type[src]
impl Hash for Type[src]
impl Parse for Type[src]
impl PartialEq<Type> for Type[src]
impl Parse for Type[src]
impl PartialEq<Type> for Type[src]
impl ToTokens for Type[src]
Auto Trait Implementations
Blanket Implementations
impl<T> Any for T where
    T: 'static + ?Sized, [src]
impl<T> Borrow<T> for T where
    T: ?Sized, [src]
impl<T> BorrowMut<T> for T where
    T: ?Sized, [src]
impl<T> From<T> for T[src]
impl<T, U> Into<U> for T where
    U: From<T>, [src]
Auto Trait Implementations
impl RefUnwindSafe for Type
impl !Send for Type
impl !Sync for Type
impl Unpin for Type
impl UnwindSafe for Type
Blanket Implementations
impl<T> Any for T where
    T: 'static + ?Sized, [src]
impl<T> Borrow<T> for T where
    T: ?Sized, [src]
impl<T> BorrowMut<T> for T where
    T: ?Sized, [src]
impl<T> From<T> for T[src]
impl<T, U> Into<U> for T where
    U: From<T>, [src]
impl<T> Spanned for T where
    T: Spanned + ?Sized, [src]
impl<T> ToOwned for T where
    T: Clone, [src]
type Owned = T
The resulting type after obtaining ownership.

-
impl<T> ToOwned for T where
    T: Clone, [src]
type Owned = T
The resulting type after obtaining ownership.

+
impl<T, U> TryFrom<U> for T where
    U: Into<T>, [src]
type Error = Infallible
The type returned in the event of a conversion error.

-
impl<T, U> TryInto<U> for T where
    U: TryFrom<T>, [src]
type Error = <U as TryFrom<T>>::Error
The type returned in the event of a conversion error.

-

\ No newline at end of file
+

impl<T, U> TryFrom<U> for T where
    U: Into<T>, [src]

type Error = Infallible

The type returned in the event of a conversion error.

+

impl<T, U> TryInto<U> for T where
    U: TryFrom<T>, [src]

type Error = <U as TryFrom<T>>::Error

The type returned in the event of a conversion error.

+
+ \ No newline at end of file diff --git a/syn/enum.TypeParamBound.html b/syn/enum.TypeParamBound.html index f2bd9ee..6bb0144 100644 --- a/syn/enum.TypeParamBound.html +++ b/syn/enum.TypeParamBound.html @@ -1,7 +1,7 @@ -syn::TypeParamBound - Rust +syn::TypeParamBound - Rust -

[−][src]Enum syn::TypeParamBound

pub enum TypeParamBound {
+
Enum syn::TypeParamBound[−][src]
pub enum TypeParamBound {
     Trait(TraitBound),
     Lifetime(Lifetime),
 }
A trait or lifetime used as a bound on a type parameter.

@@ -10,31 +10,32 @@ feature.

 

                    Variants

 
Trait(TraitBound)
Lifetime(Lifetime)
Trait Implementations
impl Clone for TypeParamBound[src]
impl Debug for TypeParamBound[src]
impl Eq for TypeParamBound[src]
impl From<Lifetime> for TypeParamBound[src]
impl From<TraitBound> for TypeParamBound[src]
impl Eq for TypeParamBound[src]
impl From<Lifetime> for TypeParamBound[src]
impl From<TraitBound> for TypeParamBound[src]
impl Hash for TypeParamBound[src]
impl Parse for TypeParamBound[src]
impl PartialEq<TypeParamBound> for TypeParamBound[src]
impl Parse for TypeParamBound[src]
impl PartialEq<TypeParamBound> for TypeParamBound[src]
impl ToTokens for TypeParamBound[src]
Auto Trait Implementations
Blanket Implementations
impl<T> Any for T where
    T: 'static + ?Sized, [src]
impl<T> Borrow<T> for T where
    T: ?Sized, [src]
impl<T> BorrowMut<T> for T where
    T: ?Sized, [src]
impl<T> From<T> for T[src]
impl<T, U> Into<U> for T where
    U: From<T>, [src]
impl ToTokens for TypeParamBound[src]
Auto Trait Implementations
Blanket Implementations
impl<T> Any for T where
    T: 'static + ?Sized, [src]
impl<T> Borrow<T> for T where
    T: ?Sized, [src]
impl<T> BorrowMut<T> for T where
    T: ?Sized, [src]
impl<T> From<T> for T[src]
impl<T, U> Into<U> for T where
    U: From<T>, [src]
impl<T> Spanned for T where
    T: Spanned + ?Sized, [src]
impl<T> ToOwned for T where
    T: Clone, [src]
type Owned = T
The resulting type after obtaining ownership.

-
impl<T> ToOwned for T where
    T: Clone, [src]
type Owned = T
The resulting type after obtaining ownership.

+
impl<T, U> TryFrom<U> for T where
    U: Into<T>, [src]
type Error = Infallible
The type returned in the event of a conversion error.

-
impl<T, U> TryInto<U> for T where
    U: TryFrom<T>, [src]
type Error = <U as TryFrom<T>>::Error
The type returned in the event of a conversion error.

-

\ No newline at end of file
+

impl<T, U> TryFrom<U> for T where
    U: Into<T>, [src]

type Error = Infallible

The type returned in the event of a conversion error.

+

impl<T, U> TryInto<U> for T where
    U: TryFrom<T>, [src]

type Error = <U as TryFrom<T>>::Error

The type returned in the event of a conversion error.

+
+ \ No newline at end of file diff --git a/syn/enum.UnOp.html b/syn/enum.UnOp.html index 2568267..636a599 100644 --- a/syn/enum.UnOp.html +++ b/syn/enum.UnOp.html @@ -1,7 +1,7 @@ -syn::UnOp - Rust +syn::UnOp - Rust -

[−][src]Enum syn::UnOp

pub enum UnOp {
+
Enum syn::UnOp[−][src]
pub enum UnOp {
     Deref(Star),
     Not(Bang),
     Neg(Sub),
@@ -14,29 +14,30 @@ feature.

 
Not(Bang)
The ! operator for logical inversion

 
Neg(Sub)
The - operator for negation

 
Trait Implementations
impl Clone for UnOp[src]
impl Copy for UnOp[src]
impl Debug for UnOp[src]
impl Eq for UnOp[src]
impl Hash for UnOp[src]
impl Parse for UnOp[src]
impl PartialEq<UnOp> for UnOp[src]
impl ToTokens for UnOp[src]
Auto Trait Implementations
Blanket Implementations
impl<T> Any for T where
    T: 'static + ?Sized, [src]
impl<T> Borrow<T> for T where
    T: ?Sized, [src]
impl<T> BorrowMut<T> for T where
    T: ?Sized, [src]
impl<T> From<T> for T[src]
impl<T, U> Into<U> for T where
    U: From<T>, [src]
Auto Trait Implementations
impl RefUnwindSafe for UnOp
impl !Send for UnOp
impl !Sync for UnOp
impl Unpin for UnOp
impl UnwindSafe for UnOp
Blanket Implementations
impl<T> Any for T where
    T: 'static + ?Sized, [src]
impl<T> Borrow<T> for T where
    T: ?Sized, [src]
impl<T> BorrowMut<T> for T where
    T: ?Sized, [src]
impl<T> From<T> for T[src]
impl<T, U> Into<U> for T where
    U: From<T>, [src]
impl<T> Spanned for T where
    T: Spanned + ?Sized, [src]
impl<T> ToOwned for T where
    T: Clone, [src]
type Owned = T
The resulting type after obtaining ownership.

-
impl<T> ToOwned for T where
    T: Clone, [src]
type Owned = T
The resulting type after obtaining ownership.

+
impl<T, U> TryFrom<U> for T where
    U: Into<T>, [src]
type Error = Infallible
The type returned in the event of a conversion error.

-
impl<T, U> TryInto<U> for T where
    U: TryFrom<T>, [src]
type Error = <U as TryFrom<T>>::Error
The type returned in the event of a conversion error.

-

\ No newline at end of file
+

impl<T, U> TryFrom<U> for T where
    U: Into<T>, [src]

type Error = Infallible

The type returned in the event of a conversion error.

+

impl<T, U> TryInto<U> for T where
    U: TryFrom<T>, [src]

type Error = <U as TryFrom<T>>::Error

The type returned in the event of a conversion error.

+
+ \ No newline at end of file diff --git a/syn/enum.Visibility.html b/syn/enum.Visibility.html index 2c8c994..50dd2b0 100644 --- a/syn/enum.Visibility.html +++ b/syn/enum.Visibility.html @@ -1,7 +1,7 @@ -syn::Visibility - Rust +syn::Visibility - Rust -

[−][src]Enum syn::Visibility

pub enum Visibility {
+
Enum syn::Visibility[−][src]
pub enum Visibility {
     Public(VisPublic),
     Crate(VisCrate),
     Restricted(VisRestricted),
@@ -20,32 +20,33 @@ feature.

 pub(super) or pub(crate) or pub(in some::module).

 
Inherited
An inherited visibility, which usually means private.

 
Trait Implementations
impl Clone for Visibility[src]
impl Debug for Visibility[src]
impl Eq for Visibility[src]
impl From<VisCrate> for Visibility[src]
impl From<VisPublic> for Visibility[src]
impl From<VisRestricted> for Visibility[src]
impl Hash for Visibility[src]
impl Parse for Visibility[src]
impl PartialEq<Visibility> for Visibility[src]
impl Parse for Visibility[src]
impl PartialEq<Visibility> for Visibility[src]
impl ToTokens for Visibility[src]
Auto Trait Implementations
Blanket Implementations
impl<T> Any for T where
    T: 'static + ?Sized, [src]
impl<T> Borrow<T> for T where
    T: ?Sized, [src]
impl<T> BorrowMut<T> for T where
    T: ?Sized, [src]
impl<T> From<T> for T[src]
impl<T, U> Into<U> for T where
    U: From<T>, [src]
Auto Trait Implementations
Blanket Implementations
impl<T> Any for T where
    T: 'static + ?Sized, [src]
impl<T> Borrow<T> for T where
    T: ?Sized, [src]
impl<T> BorrowMut<T> for T where
    T: ?Sized, [src]
impl<T> From<T> for T[src]
impl<T, U> Into<U> for T where
    U: From<T>, [src]
impl<T> Spanned for T where
    T: Spanned + ?Sized, [src]
impl<T> ToOwned for T where
    T: Clone, [src]
type Owned = T
The resulting type after obtaining ownership.

-
impl<T> ToOwned for T where
    T: Clone, [src]
type Owned = T
The resulting type after obtaining ownership.

+
impl<T, U> TryFrom<U> for T where
    U: Into<T>, [src]
type Error = Infallible
The type returned in the event of a conversion error.

-
impl<T, U> TryInto<U> for T where
    U: TryFrom<T>, [src]
type Error = <U as TryFrom<T>>::Error
The type returned in the event of a conversion error.

-

\ No newline at end of file
+

impl<T, U> TryFrom<U> for T where
    U: Into<T>, [src]

type Error = Infallible

The type returned in the event of a conversion error.

+

impl<T, U> TryInto<U> for T where
    U: TryFrom<T>, [src]

type Error = <U as TryFrom<T>>::Error

The type returned in the event of a conversion error.

+
+ \ No newline at end of file diff --git a/syn/enum.WherePredicate.html b/syn/enum.WherePredicate.html index 7c426ef..666e8fd 100644 --- a/syn/enum.WherePredicate.html +++ b/syn/enum.WherePredicate.html @@ -1,7 +1,7 @@ -syn::WherePredicate - Rust +syn::WherePredicate - Rust -

[−][src]Enum syn::WherePredicate

pub enum WherePredicate {
+
Enum syn::WherePredicate[−][src]
pub enum WherePredicate {
     Type(PredicateType),
     Lifetime(PredicateLifetime),
     Eq(PredicateEq),
@@ -16,32 +16,33 @@ feature.

 
A lifetime predicate in a where clause: 'a: 'b + 'c.

 
An equality predicate in a where clause (unsupported).

 
Trait Implementations
impl Clone for WherePredicate[src]
impl Debug for WherePredicate[src]
impl Eq for WherePredicate[src]
impl From<PredicateEq> for WherePredicate[src]
impl From<PredicateLifetime> for WherePredicate[src]
impl From<PredicateType> for WherePredicate[src]
impl Eq for WherePredicate[src]
impl From<PredicateEq> for WherePredicate[src]
impl From<PredicateLifetime> for WherePredicate[src]
impl From<PredicateType> for WherePredicate[src]
impl Hash for WherePredicate[src]
impl Parse for WherePredicate[src]
impl PartialEq<WherePredicate> for WherePredicate[src]
impl Parse for WherePredicate[src]
impl PartialEq<WherePredicate> for WherePredicate[src]
impl ToTokens for WherePredicate[src]
Auto Trait Implementations
Blanket Implementations
impl<T> Any for T where
    T: 'static + ?Sized, [src]
impl<T> Borrow<T> for T where
    T: ?Sized, [src]
impl<T> BorrowMut<T> for T where
    T: ?Sized, [src]
impl<T> From<T> for T[src]
impl<T, U> Into<U> for T where
    U: From<T>, [src]
impl ToTokens for WherePredicate[src]
Auto Trait Implementations
Blanket Implementations
impl<T> Any for T where
    T: 'static + ?Sized, [src]
impl<T> Borrow<T> for T where
    T: ?Sized, [src]
impl<T> BorrowMut<T> for T where
    T: ?Sized, [src]
impl<T> From<T> for T[src]
impl<T, U> Into<U> for T where
    U: From<T>, [src]
impl<T> Spanned for T where
    T: Spanned + ?Sized, [src]
impl<T> ToOwned for T where
    T: Clone, [src]
type Owned = T
The resulting type after obtaining ownership.

-
impl<T> ToOwned for T where
    T: Clone, [src]
type Owned = T
The resulting type after obtaining ownership.

+
impl<T, U> TryFrom<U> for T where
    U: Into<T>, [src]
type Error = Infallible
The type returned in the event of a conversion error.

-
impl<T, U> TryInto<U> for T where
    U: TryFrom<T>, [src]
type Error = <U as TryFrom<T>>::Error
The type returned in the event of a conversion error.

-

\ No newline at end of file
+

impl<T, U> TryFrom<U> for T where
    U: Into<T>, [src]

type Error = Infallible

The type returned in the event of a conversion error.

+

impl<T, U> TryInto<U> for T where
    U: TryFrom<T>, [src]

type Error = <U as TryFrom<T>>::Error

The type returned in the event of a conversion error.

+
+ \ No newline at end of file diff --git a/syn/ext/index.html b/syn/ext/index.html index d329404..3eeb1fc 100644 --- a/syn/ext/index.html +++ b/syn/ext/index.html @@ -1,8 +1,9 @@ -syn::ext - Rust +syn::ext - Rust -

[−][src]Module syn::ext

Extension traits to provide parsing methods on foreign types.

+

Module syn::ext[−][src]

Extension traits to provide parsing methods on foreign types.

This module is available only if Syn is built with the "parsing" feature.

Traits

IdentExt

Additional methods for Ident not provided by proc-macro2 or libproc_macro.

-
\ No newline at end of file +
+ \ No newline at end of file diff --git a/syn/ext/trait.IdentExt.html b/syn/ext/trait.IdentExt.html index 3daebdf..818345c 100644 --- a/syn/ext/trait.IdentExt.html +++ b/syn/ext/trait.IdentExt.html @@ -1,7 +1,7 @@ -syn::ext::IdentExt - Rust +syn::ext::IdentExt - Rust -

[−][src]Trait syn::ext::IdentExt

pub trait IdentExt: Sized + Sealed {
+
Trait syn::ext::IdentExt[−][src]
pub trait IdentExt: Sized + Sealed {
     const peek_any: PeekFn;
 
     fn parse_any(input: ParseStream<'_>) -> Result<Self>;
@@ -51,7 +51,7 @@ identifiers.

 different set of keywords than Rust, we might come across macro input
 that involves raw identifiers to refer to ordinary variables in the
 other language with a name that happens to be a Rust keyword.

-
The function below appends an identifier from the caller's input onto a
+
The function below appends an identifier from the caller’s input onto a
 fixed prefix. Without using unraw(), this would tend to produce
 invalid identifiers like __pyo3_get_r#move.

 
@@ -64,4 +64,5 @@ invalid identifiers like __pyo3_get_r#move.

     let getter = format!("__pyo3_get_{}", variable.unraw());
     Ident::new(&getter, Span::call_site())
 }

-
Loading content...

Implementors

impl IdentExt for Ident[src]

Loading content...
\ No newline at end of file +Loading content...

Implementors

impl IdentExt for Ident[src]

Loading content...
+ \ No newline at end of file diff --git a/syn/fn.parse.html b/syn/fn.parse.html index 6afd76b..04a47c7 100644 --- a/syn/fn.parse.html +++ b/syn/fn.parse.html @@ -1,10 +1,10 @@ -syn::parse - Rust +syn::parse - Rust -

[−][src]Function syn::parse

pub fn parse<T: Parse>(tokens: TokenStream) -> Result<T>

Parse tokens of source code into the chosen syntax tree node.

+

Function syn::parse[−][src]

pub fn parse<T: Parse>(tokens: TokenStream) -> Result<T>

Parse tokens of source code into the chosen syntax tree node.

This is preferred over parsing a string because tokens are able to preserve -information about where in the user's code they were originally written (the -"span" of the token), possibly allowing the compiler to produce better error +information about where in the user’s code they were originally written (the +“span” of the token), possibly allowing the compiler to produce better error messages.

This function parses a proc_macro::TokenStream which is the type used for interop with the compiler in a procedural macro. To parse a @@ -30,4 +30,5 @@ interop with the compiler in a procedural macro. To parse a // Convert into a token stream and return it expanded.into() }

-
\ No newline at end of file +
+ \ No newline at end of file diff --git a/syn/fn.parse2.html b/syn/fn.parse2.html index 5e39950..09eb9e2 100644 --- a/syn/fn.parse2.html +++ b/syn/fn.parse2.html @@ -1,11 +1,12 @@ -syn::parse2 - Rust +syn::parse2 - Rust -

[−][src]Function syn::parse2

pub fn parse2<T: Parse>(tokens: TokenStream) -> Result<T>

Parse a proc-macro2 token stream into the chosen syntax tree node.

+

Function syn::parse2[−][src]

pub fn parse2<T: Parse>(tokens: TokenStream) -> Result<T>

Parse a proc-macro2 token stream into the chosen syntax tree node.

This function parses a proc_macro2::TokenStream which is commonly useful when the input comes from a node of the Syn syntax tree, for example the body tokens of a Macro node. When in a procedural macro parsing the proc_macro::TokenStream provided by the compiler, use syn::parse instead.

This function is available only if Syn is built with the "parsing" feature.

-
\ No newline at end of file +
+ \ No newline at end of file diff --git a/syn/fn.parse_str.html b/syn/fn.parse_str.html index 4275dd7..f131a2a 100644 --- a/syn/fn.parse_str.html +++ b/syn/fn.parse_str.html @@ -1,7 +1,7 @@ -syn::parse_str - Rust +syn::parse_str - Rust -

[−][src]Function syn::parse_str

pub fn parse_str<T: Parse>(s: &str) -> Result<T>

Parse a string of Rust code into the chosen syntax tree node.

+

Function syn::parse_str[−][src]

pub fn parse_str<T: Parse>(s: &str) -> Result<T>

Parse a string of Rust code into the chosen syntax tree node.

This function is available only if Syn is built with the "parsing" feature.

Hygiene

Every span in the resulting syntax tree will be set to resolve at the macro @@ -16,4 +16,5 @@ call site.

println!("{:#?}", expr); Ok(()) }
-
\ No newline at end of file +
+ \ No newline at end of file diff --git a/syn/index.html b/syn/index.html index b3b7b21..29641de 100644 --- a/syn/index.html +++ b/syn/index.html @@ -1,7 +1,7 @@ -syn - Rust +syn - Rust -

[−][src]Crate syn

github crates-io docs-rs

+

Crate syn[−][src]

github crates-io docs-rs


Syn is a parsing library for parsing a stream of Rust tokens into a syntax tree of Rust source code.

@@ -32,7 +32,7 @@ involving any of our syntax tree types.

Location information — Every token parsed by Syn is associated with a Span that tracks line and column information back to the source of that token. These spans allow a procedural macro to display detailed error -messages pointing to all the right places in the user's code. There is an +messages pointing to all the right places in the user’s code. There is an example of this below.

  • @@ -45,11 +45,11 @@ time for all the rest.

    Example of a derive macro

    The canonical derive macro using Syn looks like this. We write an ordinary Rust function tagged with a proc_macro_derive attribute and the name of -the trait we are deriving. Any time that derive appears in the user's code, +the trait we are deriving. Any time that derive appears in the user’s code, the Rust compiler passes their data structure as tokens into our macro. We get to execute arbitrary Rust code to figure out what to do with those tokens, then hand some tokens back to the compiler to compile into the -user's crate.

    +user’s crate.

    [dependencies]
 syn = "1.0"
 quote = "1.0"
@@ -100,7 +100,7 @@ structures in their program.
    
 

    
 
    Spans and error reporting
    
 
    The token-based procedural macro API provides great control over where the
-compiler's error messages are displayed in user code. Consider the error the
+compiler’s error messages are displayed in user code. Consider the error the
 user sees if one of their field types does not implement HeapSize.
    
 
 
    @@ -123,7 +123,7 @@ problem.
    
 
    Parsing a custom syntax
    
 
    The lazy-static example directory shows the implementation of a
 functionlike!(...) procedural macro in which the input tokens are parsed
-using Syn's parsing API.
    
+using Syn’s parsing API.
    
 
    The example reimplements the popular lazy_static crate from crates.io as a
 procedural macro.
    
 
@@ -158,7 +158,7 @@ run cargo expand from that crate. To show the expanded code for one
 your own test cases, run cargo expand --test the_test_case where the last
 argument is the name of the test file without the .rs extension.
    
 
    This write-up by Brandon W Maister discusses debugging in more detail:
-Debugging Rust's new Custom Derive system.
    
+Debugging Rust’s new Custom Derive system.
    
 
    
 
    Optional features
    
 
    Syn puts a lot of functionality behind optional features in order to
@@ -356,4 +356,5 @@ expression.
    
 
    AttributeArgs
    Conventional argument type associated with an invocation of an attribute
 macro.
    
 
    Result
    The result of a Syn parser.
    
-
    • \ No newline at end of file +
    + \ No newline at end of file diff --git a/syn/macro.Token.html b/syn/macro.Token.html index 3f481d3..b241de5 100644 --- a/syn/macro.Token.html +++ b/syn/macro.Token.html @@ -1,7 +1,7 @@ -syn::Token - Rust +syn::Token - Rust -

    [−][src]Macro syn::Token

    +
    Macro syn::Token[−][src]
     macro_rules! Token {
     [abstract] => { ... };
     [as] => { ... };
@@ -106,4 +106,5 @@
 
    A type-macro that expands to the name of the Rust type representation of a
 given token.
    
 
    See the token module documentation for details and examples.
    
-
    
\ No newline at end of file
+
    + \ No newline at end of file diff --git a/syn/macro.braced.html b/syn/macro.braced.html index 78fed24..baa7216 100644 --- a/syn/macro.braced.html +++ b/syn/macro.braced.html @@ -1,7 +1,7 @@ -syn::braced - Rust +syn::braced - Rust -

    [−][src]Macro syn::braced

    +
    Macro syn::braced[−][src]
     macro_rules! braced {
     ($content:ident in $cursor:expr) => { ... };
 }
    
@@ -52,4 +52,5 @@
         })
     }
 }
    -
    \ No newline at end of file +
    + \ No newline at end of file diff --git a/syn/macro.bracketed.html b/syn/macro.bracketed.html index 02c5c49..ebf7556 100644 --- a/syn/macro.bracketed.html +++ b/syn/macro.bracketed.html @@ -1,7 +1,7 @@ -syn::bracketed - Rust +syn::bracketed - Rust -

    [−][src]Macro syn::bracketed

    +
    Macro syn::bracketed[−][src]
     macro_rules! bracketed {
     ($content:ident in $cursor:expr) => { ... };
 }
    
@@ -32,4 +32,5 @@ parsers.
    
         })
     }
 }
    -
    \ No newline at end of file +
    + \ No newline at end of file diff --git a/syn/macro.custom_keyword.html b/syn/macro.custom_keyword.html index cdcff35..fec1f96 100644 --- a/syn/macro.custom_keyword.html +++ b/syn/macro.custom_keyword.html @@ -1,7 +1,7 @@ -syn::custom_keyword - Rust +syn::custom_keyword - Rust -

    [−][src]Macro syn::custom_keyword

    +
    Macro syn::custom_keyword[−][src]
     macro_rules! custom_keyword {
     ($ident:ident) => { ... };
 }
    
@@ -87,4 +87,5 @@ by crates that need to use them as such.
    
         }
     }
 }
    -
    \ No newline at end of file +
    + \ No newline at end of file diff --git a/syn/macro.custom_punctuation.html b/syn/macro.custom_punctuation.html index 3783fbb..a01a411 100644 --- a/syn/macro.custom_punctuation.html +++ b/syn/macro.custom_punctuation.html @@ -1,7 +1,7 @@ -syn::custom_punctuation - Rust +syn::custom_punctuation - Rust -

    [−][src]Macro syn::custom_punctuation

    +
    Macro syn::custom_punctuation[−][src]
     macro_rules! custom_punctuation {
     ($ident:ident, $($tt:tt)+) => { ... };
 }
    
@@ -77,4 +77,5 @@ any built-in punctuation token.
    
     let input = r#" a::b </> c::d::e "#;
     let _: PathSegments = syn::parse_str(input).unwrap();
 }
    -
    \ No newline at end of file +
    + \ No newline at end of file diff --git a/syn/macro.parenthesized.html b/syn/macro.parenthesized.html index e5f9872..084b43e 100644 --- a/syn/macro.parenthesized.html +++ b/syn/macro.parenthesized.html @@ -1,7 +1,7 @@ -syn::parenthesized - Rust +syn::parenthesized - Rust -

    [−][src]Macro syn::parenthesized

    +
    Macro syn::parenthesized[−][src]
     macro_rules! parenthesized {
     ($content:ident in $cursor:expr) => { ... };
 }
    
@@ -35,4 +35,5 @@
         })
     }
 }
    -
    \ No newline at end of file +
    + \ No newline at end of file diff --git a/syn/macro.parse_macro_input.html b/syn/macro.parse_macro_input.html index 84e2060..011d226 100644 --- a/syn/macro.parse_macro_input.html +++ b/syn/macro.parse_macro_input.html @@ -1,7 +1,7 @@ -syn::parse_macro_input - Rust +syn::parse_macro_input - Rust -

    [−][src]Macro syn::parse_macro_input

    +
    Macro syn::parse_macro_input[−][src]
     macro_rules! parse_macro_input {
     ($tokenstream:ident as $ty:ty) => { ... };
     ($tokenstream:ident with $parser:path) => { ... };
@@ -66,4 +66,5 @@ multiple ways that they can be parsed.
    
     Ok(syntax_tree) => syntax_tree,
     Err(err) => return proc_macro::TokenStream::from(err.to_compile_error()),
 }
    
-
    
\ No newline at end of file
+
    + \ No newline at end of file diff --git a/syn/macro.parse_quote.html b/syn/macro.parse_quote.html index 442092c..e800490 100644 --- a/syn/macro.parse_quote.html +++ b/syn/macro.parse_quote.html @@ -1,7 +1,7 @@ -syn::parse_quote - Rust +syn::parse_quote - Rust -

    [−][src]Macro syn::parse_quote

    +
    Macro syn::parse_quote[−][src]
     macro_rules! parse_quote {
     ($($tt:tt)*) => { ... };
 }
    
@@ -57,4 +57,5 @@ or inner like #![...]
 
    Panics if the tokens fail to parse as the expected syntax tree type. The
 caller is responsible for ensuring that the input tokens are syntactically
 valid.
    
-
    
\ No newline at end of file
+
    + \ No newline at end of file diff --git a/syn/parse/discouraged/index.html b/syn/parse/discouraged/index.html index fc76bf1..66f862b 100644 --- a/syn/parse/discouraged/index.html +++ b/syn/parse/discouraged/index.html @@ -1,7 +1,8 @@ -syn::parse::discouraged - Rust +syn::parse::discouraged - Rust -

    [−][src]Module syn::parse::discouraged

    Extensions to the parsing API with niche applicability.

    +

    Module syn::parse::discouraged[−][src]

    Extensions to the parsing API with niche applicability.

    Traits

    Speculative

    Extensions to the ParseStream API to support speculative parsing.

    -
    \ No newline at end of file +
    + \ No newline at end of file diff --git a/syn/parse/discouraged/trait.Speculative.html b/syn/parse/discouraged/trait.Speculative.html index 1d66456..fa01ce9 100644 --- a/syn/parse/discouraged/trait.Speculative.html +++ b/syn/parse/discouraged/trait.Speculative.html @@ -1,20 +1,20 @@ -syn::parse::discouraged::Speculative - Rust +syn::parse::discouraged::Speculative - Rust -

    [−][src]Trait syn::parse::discouraged::Speculative

    pub trait Speculative {
+
    Trait syn::parse::discouraged::Speculative[−][src]
    pub trait Speculative {
     fn advance_to(&self, fork: &Self);
 }
    Extensions to the ParseStream API to support speculative parsing.
    
 
    Required methods
    fn advance_to(&self, fork: &Self)[src]
    Advance this parse stream to the position of a forked parse stream.
    
 
    This is the opposite operation to ParseStream::fork. You can fork a
 parse stream, perform some speculative parsing, then join the original
-stream to the fork to "commit" the parsing from the fork to the main
+stream to the fork to “commit” the parsing from the fork to the main
 stream.
    
 
    If you can avoid doing this, you should, as it limits the ability to
 generate useful errors. That said, it is often the only way to parse
 syntax of the form A* B* for arbitrary syntax A and B. The problem
-is that when the fork fails to parse an A, it's impossible to tell
+is that when the fork fails to parse an A, it’s impossible to tell
 whether that was because of a syntax error and the user meant to provide
-an A, or that the As are finished and it's time to start parsing
+an A, or that the As are finished and it’s time to start parsing
 Bs. Use with care.
    
 
    Also note that if A is a subset of B, A* B* can be parsed by
 parsing B* and removing the leading members of A from the
@@ -27,8 +27,8 @@ turbofish syntax like path::to::<T> no longer required by acc
 2544, PathSegment parsing should always try to consume a following
 < token as the start of generic arguments, and reset to the < if
 that fails (e.g. the token is acting as a less-than operator).
    
-
    This is the exact kind of parsing behavior which requires the "fork,
-try, commit" behavior that ParseStream::fork discourages. With
+
    This is the exact kind of parsing behavior which requires the “fork,
+try, commit” behavior that ParseStream::fork discourages. With
 advance_to, we can avoid having to parse the speculatively parsed
 content a second time.
    
 
    This change in behavior can be implemented in syn by replacing just the
@@ -76,9 +76,9 @@ content a second time.

    Drawbacks

    The main drawback of this style of speculative parsing is in error -presentation. Even if the lookahead is the "correct" parse, the error -that is shown is that of the "fallback" parse. To use the same example -as the turbofish above, take the following unfinished "turbofish":

    +presentation. Even if the lookahead is the “correct” parse, the error +that is shown is that of the “fallback” parse. To use the same example +as the turbofish above, take the following unfinished “turbofish”:

    let _ = f<&'a fn(), for<'a> serde::>();

    If this is parsed as generic arguments, we can provide the error message

    @@ -99,7 +99,7 @@ L | let _ = f<&'a fn(), for<'a> serde::>(); | ^^

    This can be mitigated with various heuristics (two examples: show both -forks' parse errors, or show the one that consumed more tokens), but +forks’ parse errors, or show the one that consumed more tokens), but when you can control the grammar, sticking to something that can be parsed LL(3) and without the LL(*) speculative parsing this makes possible, displaying reasonable errors becomes much more simple.

    @@ -110,4 +110,5 @@ on how far apart the two streams are positioned.

    The forked stream in the argument of advance_to must have been obtained by forking self. Attempting to advance to any other stream will cause a panic.

    -Loading content...

    Implementors

    impl<'a> Speculative for ParseBuffer<'a>[src]

    Loading content...
    \ No newline at end of file +Loading content...

    Implementors

    impl<'a> Speculative for ParseBuffer<'a>[src]

    Loading content...
    + \ No newline at end of file diff --git a/syn/parse/index.html b/syn/parse/index.html index d638654..f20819f 100644 --- a/syn/parse/index.html +++ b/syn/parse/index.html @@ -1,7 +1,7 @@ -syn::parse - Rust +syn::parse - Rust -

    [−][src]Module syn::parse

    Parsing interface for parsing a token stream into a syntax tree node.

    +

    Module syn::parse[−][src]

    Parsing interface for parsing a token stream into a syntax tree node.

    Parsing in Syn is built on parser functions that take in a ParseStream and produce a Result<T> where T is some syntax tree node. Underlying these parser functions is a lower level mechanism built around the @@ -80,7 +80,7 @@ implements the Pa

    The parse_quote! macro also uses this approach.

    The Parser trait

    Some types can be parsed in several ways depending on context. For example -an Attribute can be either "outer" like #[...] or "inner" like +an Attribute can be either “outer” like #[...] or “inner” like #![...] and parsing the wrong one would be a bug. Similarly Punctuated may or may not allow trailing punctuation, and parsing it the wrong way would either reject valid input or accept invalid input.

    @@ -139,4 +139,5 @@ way from a token stream.

    Type Definitions

    ParseStream

    Input to a Syn parser function.

    Result

    The result of a Syn parser.

    -
    \ No newline at end of file +
    + \ No newline at end of file diff --git a/syn/parse/struct.Error.html b/syn/parse/struct.Error.html index 9841e91..a9be5c9 100644 --- a/syn/parse/struct.Error.html +++ b/syn/parse/struct.Error.html @@ -1,7 +1,7 @@ -syn::parse::Error - Rust +syn::parse::Error - Rust -

    [−][src]Struct syn::parse::Error

    pub struct Error { /* fields omitted */ }

    Error returned when a Syn parser cannot parse the input tokens.

    +

    Struct syn::parse::Error[−][src]

    pub struct Error { /* fields omitted */ }

    Error returned when a Syn parser cannot parse the input tokens.

    Error reporting in proc macros

    The correct way to report errors back to the compiler from a procedural macro is by emitting an appropriately spanned invocation of @@ -68,7 +68,7 @@ typically be able to use the Spanned trait with the above Err constructor, implementation limitations today mean that Error::new_spanned may provide a higher-quality error message on stable Rust.

    -

    When in doubt it's recommended to stick to Error::new (or +

    When in doubt it’s recommended to stick to Error::new (or ParseStream::error)!

    pub fn span(&self) -> Span[src]

    The source location of the error.

    Spans are not thread-safe so this function returns Span::call_site() @@ -102,16 +102,16 @@ this method correctly in a procedural macro.

    pub fn combine(&mut self, another: Error)[src]

    Add another error message to self such that when to_compile_error() is called, both errors will be emitted together.

    Trait Implementations

    impl Clone for Error[src]

    impl Debug for Error[src]

    impl Display for Error[src]

    impl Error for Error[src]

    impl Error for Error[src]

    impl Extend<Error> for Error[src]

    impl From<LexError> for Error[src]

    impl IntoIterator for Error[src]

    type Item = Error

    The type of the elements being iterated over.

    type IntoIter = IntoIter

    Which kind of iterator are we turning this into?

    @@ -119,18 +119,19 @@ called, both errors will be emitted together.

    impl<'a> IntoIterator for &'a Error[src]

    type Item = Error

    The type of the elements being iterated over.

    type IntoIter = Iter<'a>

    Which kind of iterator are we turning this into?

    Auto Trait Implementations

    Blanket Implementations

    impl<T> Any for T where
        T: 'static + ?Sized,     [src]

    impl<T> Borrow<T> for T where
        T: ?Sized,     [src]

    impl<T> BorrowMut<T> for T where
        T: ?Sized,     [src]

    impl<T> From<T> for T[src]

    impl<T, U> Into<U> for T where
        U: From<T>,     [src]

    impl<T> ToOwned for T where
        T: Clone,     [src]

    type Owned = T

    The resulting type after obtaining ownership.

    -

    Auto Trait Implementations

    impl RefUnwindSafe for Error

    impl Send for Error

    impl Sync for Error

    impl Unpin for Error

    impl UnwindSafe for Error

    Blanket Implementations

    impl<T> Any for T where
        T: 'static + ?Sized,     [src]

    impl<T> Borrow<T> for T where
        T: ?Sized,     [src]

    impl<T> BorrowMut<T> for T where
        T: ?Sized,     [src]

    impl<T> From<T> for T[src]

    impl<T, U> Into<U> for T where
        U: From<T>,     [src]

    impl<T> ToOwned for T where
        T: Clone,     [src]

    type Owned = T

    The resulting type after obtaining ownership.

    +

    impl<T> ToString for T where
        T: Display + ?Sized,     [src]

    impl<T, U> TryFrom<U> for T where
        U: Into<T>,     [src]

    type Error = Infallible

    The type returned in the event of a conversion error.

    -

    impl<T, U> TryInto<U> for T where
        U: TryFrom<T>,     [src]

    type Error = <U as TryFrom<T>>::Error

    The type returned in the event of a conversion error.

    -
    \ No newline at end of file +

    impl<T> ToString for T where
        T: Display + ?Sized,     [src]

    impl<T, U> TryFrom<U> for T where
        U: Into<T>,     [src]

    type Error = Infallible

    The type returned in the event of a conversion error.

    +

    impl<T, U> TryInto<U> for T where
        U: TryFrom<T>,     [src]

    type Error = <U as TryFrom<T>>::Error

    The type returned in the event of a conversion error.

    +
    + \ No newline at end of file diff --git a/syn/parse/struct.Lookahead1.html b/syn/parse/struct.Lookahead1.html index ab5c6e4..785ec28 100644 --- a/syn/parse/struct.Lookahead1.html +++ b/syn/parse/struct.Lookahead1.html @@ -1,7 +1,7 @@ -syn::parse::Lookahead1 - Rust +syn::parse::Lookahead1 - Rust -

    [−][src]Struct syn::parse::Lookahead1

    pub struct Lookahead1<'a> { /* fields omitted */ }

    Support for checking the next token in a stream to decide how to parse.

    +

    Struct syn::parse::Lookahead1[−][src]

    pub struct Lookahead1<'a> { /* fields omitted */ }

    Support for checking the next token in a stream to decide how to parse.

    An important advantage over ParseStream::peek is that here we automatically construct an appropriate error message based on the token alternatives that get peeked. If you are producing your own error message, @@ -59,13 +59,14 @@ inside of parentheses.

    pub fn error(self) -> Error[src]

    Triggers an error at the current position of the parse stream.

    The error message will identify all of the expected token types that have been peeked against this lookahead instance.

    -

    Auto Trait Implementations

    impl<'a> !RefUnwindSafe for Lookahead1<'a>[src]

    impl<'a> !Send for Lookahead1<'a>[src]

    impl<'a> !Sync for Lookahead1<'a>[src]

    impl<'a> Unpin for Lookahead1<'a>[src]

    impl<'a> UnwindSafe for Lookahead1<'a>[src]

    Blanket Implementations

    impl<T> Any for T where
        T: 'static + ?Sized,     [src]

    impl<T> Borrow<T> for T where
        T: ?Sized,     [src]

    impl<T> BorrowMut<T> for T where
        T: ?Sized,     [src]

    impl<T> From<T> for T[src]

    impl<T, U> Into<U> for T where
        U: From<T>,     [src]

    impl<T, U> TryFrom<U> for T where
        U: Into<T>,     [src]

    type Error = Infallible

    The type returned in the event of a conversion error.

    -

    impl<T, U> TryInto<U> for T where
        U: TryFrom<T>,     [src]

    type Error = <U as TryFrom<T>>::Error

    The type returned in the event of a conversion error.

    -
    \ No newline at end of file +

    Auto Trait Implementations

    impl<'a> !RefUnwindSafe for Lookahead1<'a>

    impl<'a> !Send for Lookahead1<'a>

    impl<'a> !Sync for Lookahead1<'a>

    impl<'a> Unpin for Lookahead1<'a>

    impl<'a> UnwindSafe for Lookahead1<'a>

    Blanket Implementations

    impl<T> Any for T where
        T: 'static + ?Sized,     [src]

    impl<T> Borrow<T> for T where
        T: ?Sized,     [src]

    impl<T> BorrowMut<T> for T where
        T: ?Sized,     [src]

    impl<T> From<T> for T[src]

    impl<T, U> Into<U> for T where
        U: From<T>,     [src]

    impl<T, U> TryFrom<U> for T where
        U: Into<T>,     [src]

    type Error = Infallible

    The type returned in the event of a conversion error.

    +

    impl<T, U> TryInto<U> for T where
        U: TryFrom<T>,     [src]

    type Error = <U as TryFrom<T>>::Error

    The type returned in the event of a conversion error.

    +
    + \ No newline at end of file diff --git a/syn/parse/struct.Nothing.html b/syn/parse/struct.Nothing.html index a9265a1..93fc30c 100644 --- a/syn/parse/struct.Nothing.html +++ b/syn/parse/struct.Nothing.html @@ -1,7 +1,7 @@ -syn::parse::Nothing - Rust +syn::parse::Nothing - Rust -

    [−][src]Struct syn::parse::Nothing

    pub struct Nothing;

    An empty syntax tree node that consumes no tokens when parsed.

    +

    Struct syn::parse::Nothing[−][src]

    pub struct Nothing;

    An empty syntax tree node that consumes no tokens when parsed.

    This is useful for attribute macros that want to ensure they are not provided any attribute args.

    @@ -22,13 +22,14 @@ provided any attribute args.

    3 | #[my_attr(asdf)] | ^^^^     -

    Trait Implementations

    impl Parse for Nothing[src]

    Auto Trait Implementations

    Blanket Implementations

    impl<T> Any for T where
        T: 'static + ?Sized,     [src]

    impl<T> Borrow<T> for T where
        T: ?Sized,     [src]

    impl<T> BorrowMut<T> for T where
        T: ?Sized,     [src]

    impl<T> From<T> for T[src]

    impl<T, U> Into<U> for T where
        U: From<T>,     [src]

    impl<T, U> TryFrom<U> for T where
        U: Into<T>,     [src]

    type Error = Infallible

    The type returned in the event of a conversion error.

    -

    impl<T, U> TryInto<U> for T where
        U: TryFrom<T>,     [src]

    type Error = <U as TryFrom<T>>::Error

    The type returned in the event of a conversion error.

    -
    \ No newline at end of file +

    Trait Implementations

    impl Parse for Nothing[src]

    Auto Trait Implementations

    impl RefUnwindSafe for Nothing

    impl Send for Nothing

    impl Sync for Nothing

    impl Unpin for Nothing

    impl UnwindSafe for Nothing

    Blanket Implementations

    impl<T> Any for T where
        T: 'static + ?Sized,     [src]

    impl<T> Borrow<T> for T where
        T: ?Sized,     [src]

    impl<T> BorrowMut<T> for T where
        T: ?Sized,     [src]

    impl<T> From<T> for T[src]

    impl<T, U> Into<U> for T where
        U: From<T>,     [src]

    impl<T, U> TryFrom<U> for T where
        U: Into<T>,     [src]

    type Error = Infallible

    The type returned in the event of a conversion error.

    +

    impl<T, U> TryInto<U> for T where
        U: TryFrom<T>,     [src]

    type Error = <U as TryFrom<T>>::Error

    The type returned in the event of a conversion error.

    +
    + \ No newline at end of file diff --git a/syn/parse/struct.ParseBuffer.html b/syn/parse/struct.ParseBuffer.html index 7b1caa8..01d2fde 100644 --- a/syn/parse/struct.ParseBuffer.html +++ b/syn/parse/struct.ParseBuffer.html @@ -1,7 +1,7 @@ -syn::parse::ParseBuffer - Rust +syn::parse::ParseBuffer - Rust -

    [−][src]Struct syn::parse::ParseBuffer

    pub struct ParseBuffer<'a> { /* fields omitted */ }

    Cursor position within a buffered token stream.

    +

    Struct syn::parse::ParseBuffer[−][src]

    pub struct ParseBuffer<'a> { /* fields omitted */ }

    Cursor position within a buffered token stream.

    This type is more commonly used through the type alias ParseStream which is an alias for &ParseBuffer.

    ParseStream is the input type for all parser functions in Syn. They have @@ -119,7 +119,7 @@ token in the input is either where or an opening curly brace.

    This is commonly useful as a way to implement contextual keywords.

    Example

    This example needs to use peek2 because the symbol union is not a -keyword in Rust. We can't use just peek and decide to parse a union if +keyword in Rust. We can’t use just peek and decide to parse a union if the very next token is union, because someone is free to write a mod union and a macro invocation that looks like union::some_macro! { ... }. In other words union is a contextual keyword.

    @@ -266,7 +266,7 @@ parse stream. Only use a fork when the amount of work performed against
 the fork is small and bounded.
    
 
    When complex speculative parsing against the forked stream is
 unavoidable, use parse::discouraged::Speculative to advance the
-original stream once the fork's parse is determined to have been
+original stream once the fork’s parse is determined to have been
 successful.
    
 
    For a lower level way to perform speculative parsing at the token level,
 consider using ParseStream::step instead.
    
@@ -413,14 +413,15 @@ will affect the state of this parse stream.

    impl<'a> Display for ParseBuffer<'a>[src]

    impl<'a> Drop for ParseBuffer<'a>[src]

    impl<'a> Speculative for ParseBuffer<'a>[src]

    Auto Trait Implementations

    impl<'a> !RefUnwindSafe for ParseBuffer<'a>[src]

    impl<'a> !Send for ParseBuffer<'a>[src]

    impl<'a> !Sync for ParseBuffer<'a>[src]

    impl<'a> Unpin for ParseBuffer<'a>[src]

    impl<'a> !UnwindSafe for ParseBuffer<'a>[src]

    Blanket Implementations

    impl<T> Any for T where
        T: 'static + ?Sized,     [src]

    impl<T> Borrow<T> for T where
        T: ?Sized,     [src]

    impl<T> BorrowMut<T> for T where
        T: ?Sized,     [src]

    impl<T> From<T> for T[src]

    impl<T, U> Into<U> for T where
        U: From<T>,     [src]

    impl<T> ToString for T where
        T: Display + ?Sized,     [src]

    impl<T, U> TryFrom<U> for T where
        U: Into<T>,     [src]

    type Error = Infallible

    The type returned in the event of a conversion error.

    -

    impl<T, U> TryInto<U> for T where
        U: TryFrom<T>,     [src]

    type Error = <U as TryFrom<T>>::Error

    The type returned in the event of a conversion error.

    -
    \ No newline at end of file +

    Auto Trait Implementations

    impl<'a> !RefUnwindSafe for ParseBuffer<'a>

    impl<'a> !Send for ParseBuffer<'a>

    impl<'a> !Sync for ParseBuffer<'a>

    impl<'a> Unpin for ParseBuffer<'a>

    impl<'a> !UnwindSafe for ParseBuffer<'a>

    Blanket Implementations

    impl<T> Any for T where
        T: 'static + ?Sized,     [src]

    impl<T> Borrow<T> for T where
        T: ?Sized,     [src]

    impl<T> BorrowMut<T> for T where
        T: ?Sized,     [src]

    impl<T> From<T> for T[src]

    impl<T, U> Into<U> for T where
        U: From<T>,     [src]

    impl<T> ToString for T where
        T: Display + ?Sized,     [src]

    impl<T, U> TryFrom<U> for T where
        U: Into<T>,     [src]

    type Error = Infallible

    The type returned in the event of a conversion error.

    +

    impl<T, U> TryInto<U> for T where
        U: TryFrom<T>,     [src]

    type Error = <U as TryFrom<T>>::Error

    The type returned in the event of a conversion error.

    +
    + \ No newline at end of file diff --git a/syn/parse/struct.StepCursor.html b/syn/parse/struct.StepCursor.html index 11713df..98171f1 100644 --- a/syn/parse/struct.StepCursor.html +++ b/syn/parse/struct.StepCursor.html @@ -1,7 +1,7 @@ -syn::parse::StepCursor - Rust +syn::parse::StepCursor - Rust -

    [−][src]Struct syn::parse::StepCursor

    pub struct StepCursor<'c, 'a> { /* fields omitted */ }

    Cursor state associated with speculative parsing.

    +

    Struct syn::parse::StepCursor[−][src]

    pub struct StepCursor<'c, 'a> { /* fields omitted */ }

    Cursor state associated with speculative parsing.

    This type is the input of the closure provided to ParseStream::step.

    Example

    @@ -30,20 +30,21 @@
 
    The ParseStream::step invocation will return this same error without
 advancing the stream state.

    Methods from Deref<Target = Cursor<'c>>

    Trait Implementations

    impl<'c, 'a> Clone for StepCursor<'c, 'a>[src]

    impl<'c, 'a> Copy for StepCursor<'c, 'a>[src]

    impl<'c, 'a> Deref for StepCursor<'c, 'a>[src]

    type Target = Cursor<'c>

    The resulting type after dereferencing.

    Auto Trait Implementations

    impl<'c, 'a> RefUnwindSafe for StepCursor<'c, 'a>[src]

    impl<'c, 'a> !Send for StepCursor<'c, 'a>[src]

    impl<'c, 'a> !Sync for StepCursor<'c, 'a>[src]

    impl<'c, 'a> Unpin for StepCursor<'c, 'a>[src]

    impl<'c, 'a> UnwindSafe for StepCursor<'c, 'a>[src]

    Blanket Implementations

    impl<T> Any for T where
        T: 'static + ?Sized,     [src]

    impl<T> Borrow<T> for T where
        T: ?Sized,     [src]

    impl<T> BorrowMut<T> for T where
        T: ?Sized,     [src]

    impl<T> From<T> for T[src]

    impl<T, U> Into<U> for T where
        U: From<T>,     [src]

    impl<T> ToOwned for T where
        T: Clone,     [src]

    type Owned = T

    The resulting type after obtaining ownership.

    -

    Auto Trait Implementations

    impl<'c, 'a> RefUnwindSafe for StepCursor<'c, 'a>

    impl<'c, 'a> !Send for StepCursor<'c, 'a>

    impl<'c, 'a> !Sync for StepCursor<'c, 'a>

    impl<'c, 'a> Unpin for StepCursor<'c, 'a>

    impl<'c, 'a> UnwindSafe for StepCursor<'c, 'a>

    Blanket Implementations

    impl<T> Any for T where
        T: 'static + ?Sized,     [src]

    impl<T> Borrow<T> for T where
        T: ?Sized,     [src]

    impl<T> BorrowMut<T> for T where
        T: ?Sized,     [src]

    impl<T> From<T> for T[src]

    impl<T, U> Into<U> for T where
        U: From<T>,     [src]

    impl<T> ToOwned for T where
        T: Clone,     [src]

    type Owned = T

    The resulting type after obtaining ownership.

    +

    impl<T, U> TryFrom<U> for T where
        U: Into<T>,     [src]

    type Error = Infallible

    The type returned in the event of a conversion error.

    -

    impl<T, U> TryInto<U> for T where
        U: TryFrom<T>,     [src]

    type Error = <U as TryFrom<T>>::Error

    The type returned in the event of a conversion error.

    -
    \ No newline at end of file +

    impl<T, U> TryFrom<U> for T where
        U: Into<T>,     [src]

    type Error = Infallible

    The type returned in the event of a conversion error.

    +

    impl<T, U> TryInto<U> for T where
        U: TryFrom<T>,     [src]

    type Error = <U as TryFrom<T>>::Error

    The type returned in the event of a conversion error.

    +
    + \ No newline at end of file diff --git a/syn/parse/trait.Parse.html b/syn/parse/trait.Parse.html index b879faa..b328d0b 100644 --- a/syn/parse/trait.Parse.html +++ b/syn/parse/trait.Parse.html @@ -1,10 +1,11 @@ -syn::parse::Parse - Rust +syn::parse::Parse - Rust -

    [−][src]Trait syn::parse::Parse

    pub trait Parse: Sized {
+
    Trait syn::parse::Parse[−][src]
    pub trait Parse: Sized {
     fn parse(input: ParseStream<'_>) -> Result<Self>;
 }
    Parsing interface implemented by all types that can be parsed in a default
 way from a token stream.
    
 
    Refer to the module documentation for details about implementing and using
 the Parse trait.
    
-
    Required methods
    fn parse(input: ParseStream<'_>) -> Result<Self>[src]
    Loading content...
    Implementations on Foreign Types
    impl Parse for Option<BoundLifetimes>[src]
    impl Parse for Option<WhereClause>[src]
    impl Parse for Option<Abi>[src]
    impl<T: Parse> Parse for Box<T>[src]
    impl<T: Parse + Token> Parse for Option<T>[src]
    impl Parse for TokenStream[src]
    impl Parse for TokenTree[src]
    impl Parse for Group[src]
    impl Parse for Punct[src]
    impl Parse for Literal[src]
    Loading content...
    Implementors
    impl Parse for BinOp[src]
    impl Parse for Expr[src]
    impl Parse for GenericArgument[src]
    impl Parse for GenericParam[src]
    impl Parse for Lit[src]
    impl Parse for Member[src]
    impl Parse for Meta[src]
    impl Parse for NestedMeta[src]
    impl Parse for ReturnType[src]
    impl Parse for TraitBoundModifier[src]
    impl Parse for syn::Type[src]
    impl Parse for TypeParamBound[src]
    impl Parse for UnOp[src]
    impl Parse for Visibility[src]
    impl Parse for WherePredicate[src]
    impl Parse for Nothing[src]
    impl Parse for Abi[src]
    impl Parse for AngleBracketedGenericArguments[src]
    impl Parse for BareFnArg[src]
    impl Parse for Binding[src]
    impl Parse for BoundLifetimes[src]
    impl Parse for ConstParam[src]
    impl Parse for DeriveInput[src]
    impl Parse for ExprLit[src]
    impl Parse for ExprPath[src]
    impl Parse for FieldsNamed[src]
    impl Parse for FieldsUnnamed[src]
    impl Parse for Generics[src]
    impl Parse for Ident[src]
    impl Parse for Index[src]
    impl Parse for Lifetime[src]
    impl Parse for LifetimeDef[src]
    impl Parse for LitBool[src]
    impl Parse for LitByte[src]
    impl Parse for LitByteStr[src]
    impl Parse for LitChar[src]
    impl Parse for LitFloat[src]
    impl Parse for LitInt[src]
    impl Parse for LitStr[src]
    impl Parse for syn::Macro[src]
    impl Parse for MetaList[src]
    impl Parse for MetaNameValue[src]
    impl Parse for ParenthesizedGenericArguments[src]
    impl Parse for Path[src]
    impl Parse for PathSegment[src]
    impl Parse for TraitBound[src]
    impl Parse for TypeArray[src]
    impl Parse for TypeBareFn[src]
    impl Parse for TypeGroup[src]
    impl Parse for TypeImplTrait[src]
    impl Parse for TypeInfer[src]
    impl Parse for TypeMacro[src]
    impl Parse for TypeNever[src]
    impl Parse for TypeParam[src]
    impl Parse for TypeParen[src]
    impl Parse for TypePath[src]
    impl Parse for TypePtr[src]
    impl Parse for TypeReference[src]
    impl Parse for TypeSlice[src]
    impl Parse for TypeTraitObject[src]
    impl Parse for TypeTuple[src]
    impl Parse for Variant[src]
    impl Parse for WhereClause[src]
    impl Parse for Abstract[src]
    impl Parse for Add[src]
    impl Parse for AddEq[src]
    impl Parse for And[src]
    impl Parse for AndAnd[src]
    impl Parse for AndEq[src]
    impl Parse for As[src]
    impl Parse for Async[src]
    impl Parse for At[src]
    impl Parse for Auto[src]
    impl Parse for Await[src]
    impl Parse for Bang[src]
    impl Parse for Become[src]
    impl Parse for syn::token::Box[src]
    impl Parse for Break[src]
    impl Parse for Caret[src]
    impl Parse for CaretEq[src]
    impl Parse for Colon2[src]
    impl Parse for Colon[src]
    impl Parse for Comma[src]
    impl Parse for Const[src]
    impl Parse for Continue[src]
    impl Parse for Crate[src]
    impl Parse for Default[src]
    impl Parse for Div[src]
    impl Parse for DivEq[src]
    impl Parse for Do[src]
    impl Parse for Dollar[src]
    impl Parse for Dot2[src]
    impl Parse for Dot3[src]
    impl Parse for Dot[src]
    impl Parse for DotDotEq[src]
    impl Parse for Dyn[src]
    impl Parse for Else[src]
    impl Parse for Enum[src]
    impl Parse for Eq[src]
    impl Parse for EqEq[src]
    impl Parse for Extern[src]
    impl Parse for FatArrow[src]
    impl Parse for Final[src]
    impl Parse for Fn[src]
    impl Parse for For[src]
    impl Parse for Ge[src]
    impl Parse for Gt[src]
    impl Parse for If[src]
    impl Parse for Impl[src]
    impl Parse for In[src]
    impl Parse for LArrow[src]
    impl Parse for Le[src]
    impl Parse for Let[src]
    impl Parse for Loop[src]
    impl Parse for Lt[src]
    impl Parse for syn::token::Macro[src]
    impl Parse for Match[src]
    impl Parse for Mod[src]
    impl Parse for Move[src]
    impl Parse for MulEq[src]
    impl Parse for Mut[src]
    impl Parse for Ne[src]
    impl Parse for Or[src]
    impl Parse for OrEq[src]
    impl Parse for OrOr[src]
    impl Parse for Override[src]
    impl Parse for Pound[src]
    impl Parse for Priv[src]
    impl Parse for Pub[src]
    impl Parse for Question[src]
    impl Parse for RArrow[src]
    impl Parse for Ref[src]
    impl Parse for Rem[src]
    impl Parse for RemEq[src]
    impl Parse for Return[src]
    impl Parse for SelfType[src]
    impl Parse for SelfValue[src]
    impl Parse for Semi[src]
    impl Parse for Shl[src]
    impl Parse for ShlEq[src]
    impl Parse for Shr[src]
    impl Parse for ShrEq[src]
    impl Parse for Star[src]
    impl Parse for Static[src]
    impl Parse for Struct[src]
    impl Parse for Sub[src]
    impl Parse for SubEq[src]
    impl Parse for Super[src]
    impl Parse for Tilde[src]
    impl Parse for Trait[src]
    impl Parse for Try[src]
    impl Parse for syn::token::Type[src]
    impl Parse for Typeof[src]
    impl Parse for Underscore[src]
    impl Parse for Union[src]
    impl Parse for Unsafe[src]
    impl Parse for Unsized[src]
    impl Parse for Use[src]
    impl Parse for Virtual[src]
    impl Parse for Where[src]
    impl Parse for While[src]
    impl Parse for Yield[src]
    Loading content...
    
\ No newline at end of file
+

    Required methods

    fn parse(input: ParseStream<'_>) -> Result<Self>[src]

    Loading content...

    Implementations on Foreign Types

    impl Parse for Option<BoundLifetimes>[src]

    impl Parse for Option<WhereClause>[src]

    impl Parse for Option<Abi>[src]

    impl<T: Parse> Parse for Box<T>[src]

    impl<T: Parse + Token> Parse for Option<T>[src]

    impl Parse for TokenStream[src]

    impl Parse for TokenTree[src]

    impl Parse for Group[src]

    impl Parse for Punct[src]

    impl Parse for Literal[src]

    Loading content...

    Implementors

    impl Parse for BinOp[src]

    impl Parse for Expr[src]

    impl Parse for GenericArgument[src]

    impl Parse for GenericParam[src]

    impl Parse for Lit[src]

    impl Parse for Member[src]

    impl Parse for Meta[src]

    impl Parse for NestedMeta[src]

    impl Parse for ReturnType[src]

    impl Parse for TraitBoundModifier[src]

    impl Parse for syn::Type[src]

    impl Parse for TypeParamBound[src]

    impl Parse for UnOp[src]

    impl Parse for Visibility[src]

    impl Parse for WherePredicate[src]

    impl Parse for Nothing[src]

    impl Parse for Abi[src]

    impl Parse for AngleBracketedGenericArguments[src]

    impl Parse for BareFnArg[src]

    impl Parse for Binding[src]

    impl Parse for BoundLifetimes[src]

    impl Parse for ConstParam[src]

    impl Parse for DeriveInput[src]

    impl Parse for ExprLit[src]

    impl Parse for ExprPath[src]

    impl Parse for FieldsNamed[src]

    impl Parse for FieldsUnnamed[src]

    impl Parse for Generics[src]

    impl Parse for Ident[src]

    impl Parse for Index[src]

    impl Parse for Lifetime[src]

    impl Parse for LifetimeDef[src]

    impl Parse for LitBool[src]

    impl Parse for LitByte[src]

    impl Parse for LitByteStr[src]

    impl Parse for LitChar[src]

    impl Parse for LitFloat[src]

    impl Parse for LitInt[src]

    impl Parse for LitStr[src]

    impl Parse for syn::Macro[src]

    impl Parse for MetaList[src]

    impl Parse for MetaNameValue[src]

    impl Parse for ParenthesizedGenericArguments[src]

    impl Parse for Path[src]

    impl Parse for PathSegment[src]

    impl Parse for TraitBound[src]

    impl Parse for TypeArray[src]

    impl Parse for TypeBareFn[src]

    impl Parse for TypeGroup[src]

    impl Parse for TypeImplTrait[src]

    impl Parse for TypeInfer[src]

    impl Parse for TypeMacro[src]

    impl Parse for TypeNever[src]

    impl Parse for TypeParam[src]

    impl Parse for TypeParen[src]

    impl Parse for TypePath[src]

    impl Parse for TypePtr[src]

    impl Parse for TypeReference[src]

    impl Parse for TypeSlice[src]

    impl Parse for TypeTraitObject[src]

    impl Parse for TypeTuple[src]

    impl Parse for Variant[src]

    impl Parse for WhereClause[src]

    impl Parse for Abstract[src]

    impl Parse for Add[src]

    impl Parse for AddEq[src]

    impl Parse for And[src]

    impl Parse for AndAnd[src]

    impl Parse for AndEq[src]

    impl Parse for As[src]

    impl Parse for Async[src]

    impl Parse for At[src]

    impl Parse for Auto[src]

    impl Parse for Await[src]

    impl Parse for Bang[src]

    impl Parse for Become[src]

    impl Parse for syn::token::Box[src]

    impl Parse for Break[src]

    impl Parse for Caret[src]

    impl Parse for CaretEq[src]

    impl Parse for Colon2[src]

    impl Parse for Colon[src]

    impl Parse for Comma[src]

    impl Parse for Const[src]

    impl Parse for Continue[src]

    impl Parse for Crate[src]

    impl Parse for Default[src]

    impl Parse for Div[src]

    impl Parse for DivEq[src]

    impl Parse for Do[src]

    impl Parse for Dollar[src]

    impl Parse for Dot2[src]

    impl Parse for Dot3[src]

    impl Parse for Dot[src]

    impl Parse for DotDotEq[src]

    impl Parse for Dyn[src]

    impl Parse for Else[src]

    impl Parse for Enum[src]

    impl Parse for Eq[src]

    impl Parse for EqEq[src]

    impl Parse for Extern[src]

    impl Parse for FatArrow[src]

    impl Parse for Final[src]

    impl Parse for Fn[src]

    impl Parse for For[src]

    impl Parse for Ge[src]

    impl Parse for Gt[src]

    impl Parse for If[src]

    impl Parse for Impl[src]

    impl Parse for In[src]

    impl Parse for LArrow[src]

    impl Parse for Le[src]

    impl Parse for Let[src]

    impl Parse for Loop[src]

    impl Parse for Lt[src]

    impl Parse for syn::token::Macro[src]

    impl Parse for Match[src]

    impl Parse for Mod[src]

    impl Parse for Move[src]

    impl Parse for MulEq[src]

    impl Parse for Mut[src]

    impl Parse for Ne[src]

    impl Parse for Or[src]

    impl Parse for OrEq[src]

    impl Parse for OrOr[src]

    impl Parse for Override[src]

    impl Parse for Pound[src]

    impl Parse for Priv[src]

    impl Parse for Pub[src]

    impl Parse for Question[src]

    impl Parse for RArrow[src]

    impl Parse for Ref[src]

    impl Parse for Rem[src]

    impl Parse for RemEq[src]

    impl Parse for Return[src]

    impl Parse for SelfType[src]

    impl Parse for SelfValue[src]

    impl Parse for Semi[src]

    impl Parse for Shl[src]

    impl Parse for ShlEq[src]

    impl Parse for Shr[src]

    impl Parse for ShrEq[src]

    impl Parse for Star[src]

    impl Parse for Static[src]

    impl Parse for Struct[src]

    impl Parse for Sub[src]

    impl Parse for SubEq[src]

    impl Parse for Super[src]

    impl Parse for Tilde[src]

    impl Parse for Trait[src]

    impl Parse for Try[src]

    impl Parse for syn::token::Type[src]

    impl Parse for Typeof[src]

    impl Parse for Underscore[src]

    impl Parse for Union[src]

    impl Parse for Unsafe[src]

    impl Parse for Unsized[src]

    impl Parse for Use[src]

    impl Parse for Virtual[src]

    impl Parse for Where[src]

    impl Parse for While[src]

    impl Parse for Yield[src]

    Loading content...
    + \ No newline at end of file diff --git a/syn/parse/trait.Parser.html b/syn/parse/trait.Parser.html index 4ecbf6f..f76c838 100644 --- a/syn/parse/trait.Parser.html +++ b/syn/parse/trait.Parser.html @@ -1,7 +1,7 @@ -syn::parse::Parser - Rust +syn::parse::Parser - Rust -

    [−][src]Trait syn::parse::Parser

    pub trait Parser: Sized {
+
    Trait syn::parse::Parser[−][src]
    pub trait Parser: Sized {
     type Output;
     fn parse2(self, tokens: TokenStream) -> Result<Self::Output>;
 
@@ -24,4 +24,5 @@ any unparsed tokens at the end of the string, an error is returned.
    
 
    Hygiene
    
 
    Every span in the resulting syntax tree will be set to resolve at the
 macro call site.
    
-
    Loading content...

    Implementors

    impl<F, T> Parser for F where
        F: FnOnce(ParseStream<'_>) -> Result<T>,     [src]

    type Output = T

    Loading content...
    \ No newline at end of file +Loading content...

    Implementors

    impl<F, T> Parser for F where
        F: FnOnce(ParseStream<'_>) -> Result<T>,     [src]

    type Output = T

    Loading content...
    + \ No newline at end of file diff --git a/syn/parse/trait.Peek.html b/syn/parse/trait.Peek.html index a076eae..08a5530 100644 --- a/syn/parse/trait.Peek.html +++ b/syn/parse/trait.Peek.html @@ -1,8 +1,9 @@ -syn::parse::Peek - Rust +syn::parse::Peek - Rust -

    [−][src]Trait syn::parse::Peek

    pub trait Peek: Sealed { }

    Types that can be parsed by looking at just one token.

    +

    Trait syn::parse::Peek[−][src]

    pub trait Peek: Sealed { }

    Types that can be parsed by looking at just one token.

    Use ParseStream::peek to peek one of these types in a parse stream without consuming it from the stream.

    This trait is sealed and cannot be implemented for types outside of Syn.

    -

    Implementors

    impl<F: Copy + FnOnce(TokenMarker) -> T, T: Token> Peek for F[src]

    type Token = T

    Loading content...
    \ No newline at end of file +

    Implementors

    impl<F: Copy + FnOnce(TokenMarker) -> T, T: Token> Peek for F[src]

    type Token = T

    Loading content...
    + \ No newline at end of file diff --git a/syn/parse/type.ParseStream.html b/syn/parse/type.ParseStream.html index e9d0e8d..3872853 100644 --- a/syn/parse/type.ParseStream.html +++ b/syn/parse/type.ParseStream.html @@ -1,7 +1,8 @@ -syn::parse::ParseStream - Rust +syn::parse::ParseStream - Rust -

    [−][src]Type Definition syn::parse::ParseStream

    type ParseStream<'a> = &'a ParseBuffer<'a>;

    Input to a Syn parser function.

    +

    Type Definition syn::parse::ParseStream[−][src]

    type ParseStream<'a> = &'a ParseBuffer<'a>;

    Input to a Syn parser function.

    See the methods of this type under the documentation of ParseBuffer. For an overview of parsing in Syn, refer to the module documentation.

    -
    \ No newline at end of file +
    + \ No newline at end of file diff --git a/syn/parse/type.Result.html b/syn/parse/type.Result.html index d56fe42..6186b0e 100644 --- a/syn/parse/type.Result.html +++ b/syn/parse/type.Result.html @@ -1,5 +1,6 @@ -syn::parse::Result - Rust +syn::parse::Result - Rust -

    [−][src]Type Definition syn::parse::Result

    type Result<T> = Result<T, Error>;

    The result of a Syn parser.

    -
    \ No newline at end of file +

    Type Definition syn::parse::Result[−][src]

    type Result<T> = Result<T, Error>;

    The result of a Syn parser.

    +
    + \ No newline at end of file diff --git a/syn/punctuated/enum.Pair.html b/syn/punctuated/enum.Pair.html index 27cf378..c8b7fa8 100644 --- a/syn/punctuated/enum.Pair.html +++ b/syn/punctuated/enum.Pair.html @@ -1,7 +1,7 @@ -syn::punctuated::Pair - Rust +syn::punctuated::Pair - Rust -

    [−][src]Enum syn::punctuated::Pair

    pub enum Pair<T, P> {
+
    Enum syn::punctuated::Pair[−][src]
    pub enum Pair<T, P> {
     Punctuated(T, P),
     End(T),
 }
    A single syntax tree node of type T followed by its trailing punctuation
@@ -20,27 +20,28 @@ following punctuation.
    
 
    pub fn into_tuple(self) -> (T, Option<P>)[src]
    Produces this punctuated pair as a tuple of syntax tree node and
 optional following punctuation.

    Trait Implementations

    impl<T, P> Clone for Pair<T, P> where
        T: Clone,
        P: Clone,     [src]

    impl<T, P> Extend<Pair<T, P>> for Punctuated<T, P>[src]

    impl<T, P> FromIterator<Pair<T, P>> for Punctuated<T, P>[src]

    impl<T, P> ToTokens for Pair<T, P> where
        T: ToTokens,
        P: ToTokens,     [src]

    Auto Trait Implementations

    impl<T, P> RefUnwindSafe for Pair<T, P> where
        P: RefUnwindSafe,
        T: RefUnwindSafe,     [src]

    impl<T, P> Send for Pair<T, P> where
        P: Send,
        T: Send,     [src]

    impl<T, P> Sync for Pair<T, P> where
        P: Sync,
        T: Sync,     [src]

    impl<T, P> Unpin for Pair<T, P> where
        P: Unpin,
        T: Unpin,     [src]

    impl<T, P> UnwindSafe for Pair<T, P> where
        P: UnwindSafe,
        T: UnwindSafe,     [src]

    Blanket Implementations

    impl<T> Any for T where
        T: 'static + ?Sized,     [src]

    impl<T> Borrow<T> for T where
        T: ?Sized,     [src]

    impl<T> BorrowMut<T> for T where
        T: ?Sized,     [src]

    impl<T> From<T> for T[src]

    impl<T, U> Into<U> for T where
        U: From<T>,     [src]

    Auto Trait Implementations

    impl<T, P> RefUnwindSafe for Pair<T, P> where
        P: RefUnwindSafe,
        T: RefUnwindSafe, 

    impl<T, P> Send for Pair<T, P> where
        P: Send,
        T: Send, 

    impl<T, P> Sync for Pair<T, P> where
        P: Sync,
        T: Sync, 

    impl<T, P> Unpin for Pair<T, P> where
        P: Unpin,
        T: Unpin, 

    impl<T, P> UnwindSafe for Pair<T, P> where
        P: UnwindSafe,
        T: UnwindSafe, 

    Blanket Implementations

    impl<T> Any for T where
        T: 'static + ?Sized,     [src]

    impl<T> Borrow<T> for T where
        T: ?Sized,     [src]

    impl<T> BorrowMut<T> for T where
        T: ?Sized,     [src]

    impl<T> From<T> for T[src]

    impl<T, U> Into<U> for T where
        U: From<T>,     [src]

    impl<T> Spanned for T where
        T: Spanned + ?Sized,     [src]

    impl<T> ToOwned for T where
        T: Clone,     [src]

    type Owned = T

    The resulting type after obtaining ownership.

    -

    impl<T> ToOwned for T where
        T: Clone,     [src]

    type Owned = T

    The resulting type after obtaining ownership.

    +

    impl<T, U> TryFrom<U> for T where
        U: Into<T>,     [src]

    type Error = Infallible

    The type returned in the event of a conversion error.

    -

    impl<T, U> TryInto<U> for T where
        U: TryFrom<T>,     [src]

    type Error = <U as TryFrom<T>>::Error

    The type returned in the event of a conversion error.

    -
    \ No newline at end of file +

    impl<T, U> TryFrom<U> for T where
        U: Into<T>,     [src]

    type Error = Infallible

    The type returned in the event of a conversion error.

    +

    impl<T, U> TryInto<U> for T where
        U: TryFrom<T>,     [src]

    type Error = <U as TryFrom<T>>::Error

    The type returned in the event of a conversion error.

    +
    + \ No newline at end of file diff --git a/syn/punctuated/index.html b/syn/punctuated/index.html index a3c3161..2273288 100644 --- a/syn/punctuated/index.html +++ b/syn/punctuated/index.html @@ -1,7 +1,7 @@ -syn::punctuated - Rust +syn::punctuated - Rust -

    [−][src]Module syn::punctuated

    A punctuated sequence of syntax tree nodes separated by punctuation.

    +

    Module syn::punctuated[−][src]

    A punctuated sequence of syntax tree nodes separated by punctuation.

    Lots of things in Rust are punctuated sequences.

    • The fields of a struct are Punctuated<Field, Token![,]>.
      • @@ -28,4 +28,5 @@ punctuation of type P.

      Enums

      Pair

      A single syntax tree node of type T followed by its trailing punctuation of type P if any.

      -
    \ No newline at end of file +
    + \ No newline at end of file diff --git a/syn/punctuated/struct.IntoIter.html b/syn/punctuated/struct.IntoIter.html index 4d95934..1f09bf9 100644 --- a/syn/punctuated/struct.IntoIter.html +++ b/syn/punctuated/struct.IntoIter.html @@ -1,146 +1,152 @@ -syn::punctuated::IntoIter - Rust +syn::punctuated::IntoIter - Rust -

    [−][src]Struct syn::punctuated::IntoIter

    pub struct IntoIter<T> { /* fields omitted */ }

    An iterator over owned values of type T.

    +

    Struct syn::punctuated::IntoIter[−][src]

    pub struct IntoIter<T> { /* fields omitted */ }

    An iterator over owned values of type T.

    Refer to the module documentation for details about punctuated sequences.

    Trait Implementations

    impl<T> Clone for IntoIter<T> where
        T: Clone,     [src]

    impl<T> DoubleEndedIterator for IntoIter<T>[src]

    impl<T> ExactSizeIterator for IntoIter<T>[src]

    impl<T> Iterator for IntoIter<T>[src]

    type Item = T

    The type of the elements being iterated over.

    \ No newline at end of file +

    impl<T, U> TryFrom<U> for T where
        U: Into<T>,     [src]

    type Error = Infallible

    The type returned in the event of a conversion error.

    +

    impl<T, U> TryInto<U> for T where
        U: TryFrom<T>,     [src]

    type Error = <U as TryFrom<T>>::Error

    The type returned in the event of a conversion error.

    +
    + \ No newline at end of file diff --git a/syn/punctuated/struct.IntoPairs.html b/syn/punctuated/struct.IntoPairs.html index 08e18f8..8851aa8 100644 --- a/syn/punctuated/struct.IntoPairs.html +++ b/syn/punctuated/struct.IntoPairs.html @@ -1,146 +1,152 @@ -syn::punctuated::IntoPairs - Rust +syn::punctuated::IntoPairs - Rust -

    [−][src]Struct syn::punctuated::IntoPairs

    pub struct IntoPairs<T, P> { /* fields omitted */ }

    An iterator over owned pairs of type Pair<T, P>.

    +

    Struct syn::punctuated::IntoPairs[−][src]

    pub struct IntoPairs<T, P> { /* fields omitted */ }

    An iterator over owned pairs of type Pair<T, P>.

    Refer to the module documentation for details about punctuated sequences.

    Trait Implementations

    impl<T, P> Clone for IntoPairs<T, P> where
        T: Clone,
        P: Clone,     [src]

    impl<T, P> DoubleEndedIterator for IntoPairs<T, P>[src]

    impl<T, P> ExactSizeIterator for IntoPairs<T, P>[src]

    impl<T, P> Iterator for IntoPairs<T, P>[src]

    type Item = Pair<T, P>

    The type of the elements being iterated over.

    \ No newline at end of file +

    impl<T, U> TryFrom<U> for T where
        U: Into<T>,     [src]

    type Error = Infallible

    The type returned in the event of a conversion error.

    +

    impl<T, U> TryInto<U> for T where
        U: TryFrom<T>,     [src]

    type Error = <U as TryFrom<T>>::Error

    The type returned in the event of a conversion error.

    +
    + \ No newline at end of file diff --git a/syn/punctuated/struct.Iter.html b/syn/punctuated/struct.Iter.html index 188d501..4cbf4c8 100644 --- a/syn/punctuated/struct.Iter.html +++ b/syn/punctuated/struct.Iter.html @@ -1,146 +1,152 @@ -syn::punctuated::Iter - Rust +syn::punctuated::Iter - Rust -

    [−][src]Struct syn::punctuated::Iter

    pub struct Iter<'a, T: 'a> { /* fields omitted */ }

    An iterator over borrowed values of type &T.

    +

    Struct syn::punctuated::Iter[−][src]

    pub struct Iter<'a, T: 'a> { /* fields omitted */ }

    An iterator over borrowed values of type &T.

    Refer to the module documentation for details about punctuated sequences.

    Trait Implementations

    impl<'a, T> Clone for Iter<'a, T>[src]

    impl<'a, T> DoubleEndedIterator for Iter<'a, T>[src]

    impl<'a, T> ExactSizeIterator for Iter<'a, T>[src]

    impl<'a, T> Iterator for Iter<'a, T>[src]

    type Item = &'a T

    The type of the elements being iterated over.

    \ No newline at end of file +

    impl<T, U> TryFrom<U> for T where
        U: Into<T>,     [src]

    type Error = Infallible

    The type returned in the event of a conversion error.

    +

    impl<T, U> TryInto<U> for T where
        U: TryFrom<T>,     [src]

    type Error = <U as TryFrom<T>>::Error

    The type returned in the event of a conversion error.

    +
    + \ No newline at end of file diff --git a/syn/punctuated/struct.IterMut.html b/syn/punctuated/struct.IterMut.html index 0a6f639..61c1809 100644 --- a/syn/punctuated/struct.IterMut.html +++ b/syn/punctuated/struct.IterMut.html @@ -1,140 +1,146 @@ -syn::punctuated::IterMut - Rust +syn::punctuated::IterMut - Rust -

    [−][src]Struct syn::punctuated::IterMut

    pub struct IterMut<'a, T: 'a> { /* fields omitted */ }

    An iterator over mutably borrowed values of type &mut T.

    +

    Struct syn::punctuated::IterMut[−][src]

    pub struct IterMut<'a, T: 'a> { /* fields omitted */ }

    An iterator over mutably borrowed values of type &mut T.

    Refer to the module documentation for details about punctuated sequences.

    Trait Implementations

    impl<'a, T> DoubleEndedIterator for IterMut<'a, T>[src]

    impl<'a, T> ExactSizeIterator for IterMut<'a, T>[src]

    impl<'a, T> Iterator for IterMut<'a, T>[src]

    type Item = &'a mut T

    The type of the elements being iterated over.

    \ No newline at end of file +

    impl<T, U> TryFrom<U> for T where
        U: Into<T>,     [src]

    type Error = Infallible

    The type returned in the event of a conversion error.

    +

    impl<T, U> TryInto<U> for T where
        U: TryFrom<T>,     [src]

    type Error = <U as TryFrom<T>>::Error

    The type returned in the event of a conversion error.

    +
    + \ No newline at end of file diff --git a/syn/punctuated/struct.Pairs.html b/syn/punctuated/struct.Pairs.html index 082c6a7..fb99073 100644 --- a/syn/punctuated/struct.Pairs.html +++ b/syn/punctuated/struct.Pairs.html @@ -1,146 +1,152 @@ -syn::punctuated::Pairs - Rust +syn::punctuated::Pairs - Rust -

    [−][src]Struct syn::punctuated::Pairs

    pub struct Pairs<'a, T: 'a, P: 'a> { /* fields omitted */ }

    An iterator over borrowed pairs of type Pair<&T, &P>.

    +

    Struct syn::punctuated::Pairs[−][src]

    pub struct Pairs<'a, T: 'a, P: 'a> { /* fields omitted */ }

    An iterator over borrowed pairs of type Pair<&T, &P>.

    Refer to the module documentation for details about punctuated sequences.

    Trait Implementations

    impl<'a, T, P> Clone for Pairs<'a, T, P>[src]

    impl<'a, T, P> DoubleEndedIterator for Pairs<'a, T, P>[src]

    impl<'a, T, P> ExactSizeIterator for Pairs<'a, T, P>[src]

    impl<'a, T, P> Iterator for Pairs<'a, T, P>[src]

    type Item = Pair<&'a T, &'a P>

    The type of the elements being iterated over.

    \ No newline at end of file +

    impl<T, U> TryFrom<U> for T where
        U: Into<T>,     [src]

    type Error = Infallible

    The type returned in the event of a conversion error.

    +

    impl<T, U> TryInto<U> for T where
        U: TryFrom<T>,     [src]

    type Error = <U as TryFrom<T>>::Error

    The type returned in the event of a conversion error.

    +
    + \ No newline at end of file diff --git a/syn/punctuated/struct.PairsMut.html b/syn/punctuated/struct.PairsMut.html index 2e45146..b81408b 100644 --- a/syn/punctuated/struct.PairsMut.html +++ b/syn/punctuated/struct.PairsMut.html @@ -1,140 +1,146 @@ -syn::punctuated::PairsMut - Rust +syn::punctuated::PairsMut - Rust -

    [−][src]Struct syn::punctuated::PairsMut

    pub struct PairsMut<'a, T: 'a, P: 'a> { /* fields omitted */ }

    An iterator over mutably borrowed pairs of type Pair<&mut T, &mut P>.

    +

    Struct syn::punctuated::PairsMut[−][src]

    pub struct PairsMut<'a, T: 'a, P: 'a> { /* fields omitted */ }

    An iterator over mutably borrowed pairs of type Pair<&mut T, &mut P>.

    Refer to the module documentation for details about punctuated sequences.

    Trait Implementations

    impl<'a, T, P> DoubleEndedIterator for PairsMut<'a, T, P>[src]

    impl<'a, T, P> ExactSizeIterator for PairsMut<'a, T, P>[src]

    impl<'a, T, P> Iterator for PairsMut<'a, T, P>[src]

    type Item = Pair<&'a mut T, &'a mut P>

    The type of the elements being iterated over.

    \ No newline at end of file +

    impl<T, U> TryFrom<U> for T where
        U: Into<T>,     [src]

    type Error = Infallible

    The type returned in the event of a conversion error.

    +

    impl<T, U> TryInto<U> for T where
        U: TryFrom<T>,     [src]

    type Error = <U as TryFrom<T>>::Error

    The type returned in the event of a conversion error.

    +
    + \ No newline at end of file diff --git a/syn/punctuated/struct.Punctuated.html b/syn/punctuated/struct.Punctuated.html index 11ce84d..2271106 100644 --- a/syn/punctuated/struct.Punctuated.html +++ b/syn/punctuated/struct.Punctuated.html @@ -1,7 +1,7 @@ -syn::punctuated::Punctuated - Rust +syn::punctuated::Punctuated - Rust -

    [−][src]Struct syn::punctuated::Punctuated

    pub struct Punctuated<T, P> { /* fields omitted */ }

    A punctuated sequence of syntax tree nodes of type T separated by +

    Struct syn::punctuated::Punctuated[−][src]

    pub struct Punctuated<T, P> { /* fields omitted */ }

    A punctuated sequence of syntax tree nodes of type T separated by punctuation of type P.

    Refer to the module documentation for details about punctuated sequences.

    Implementations

    impl<T, P> Punctuated<T, P>[src]

    pub const fn new() -> Self[src]

    Creates an empty punctuated sequence.

    @@ -80,19 +80,19 @@ the entire content of this stream.

    This function is available only if Syn is built with the "parsing" feature.

    Trait Implementations

    impl<T, P> Clone for Punctuated<T, P> where
        T: Clone,
        P: Clone,     [src]

    impl<T: Debug, P: Debug> Debug for Punctuated<T, P>[src]

    impl<T, P> Default for Punctuated<T, P>[src]

    impl<T, P> Default for Punctuated<T, P>[src]

    impl<T, P> Eq for Punctuated<T, P> where
        T: Eq,
        P: Eq,     [src]

    impl<T, P> Extend<Pair<T, P>> for Punctuated<T, P>[src]

    impl<T, P> Extend<T> for Punctuated<T, P> where
        P: Default,     [src]

    impl<T, P> FromIterator<Pair<T, P>> for Punctuated<T, P>[src]

    impl<T, P> FromIterator<T> for Punctuated<T, P> where
        P: Default,     [src]

    impl<T, P> Hash for Punctuated<T, P> where
        T: Hash,
        P: Hash,     [src]

    impl<T, P> Index<usize> for Punctuated<T, P>[src]

    type Output = T

    The returned type after indexing.

    impl<T, P> IndexMut<usize> for Punctuated<T, P>[src]

    impl<T, P> PartialEq<Punctuated<T, P>> for Punctuated<T, P> where
        T: PartialEq,
        P: PartialEq,     [src]

    impl<T, P> ToTokens for Punctuated<T, P> where
        T: ToTokens,
        P: ToTokens,     [src]

    Auto Trait Implementations

    impl<T, P> RefUnwindSafe for Punctuated<T, P> where
        P: RefUnwindSafe,
        T: RefUnwindSafe,     [src]

    impl<T, P> Send for Punctuated<T, P> where
        P: Send,
        T: Send,     [src]

    impl<T, P> Sync for Punctuated<T, P> where
        P: Sync,
        T: Sync,     [src]

    impl<T, P> Unpin for Punctuated<T, P> where
        P: Unpin,
        T: Unpin,     [src]

    impl<T, P> UnwindSafe for Punctuated<T, P> where
        P: UnwindSafe,
        T: UnwindSafe,     [src]

    Blanket Implementations

    impl<T> Any for T where
        T: 'static + ?Sized,     [src]

    impl<T> Borrow<T> for T where
        T: ?Sized,     [src]

    impl<T> BorrowMut<T> for T where
        T: ?Sized,     [src]

    impl<T> From<T> for T[src]

    impl<T, U> Into<U> for T where
        U: From<T>,     [src]

    Auto Trait Implementations

    impl<T, P> RefUnwindSafe for Punctuated<T, P> where
        P: RefUnwindSafe,
        T: RefUnwindSafe, 

    impl<T, P> Send for Punctuated<T, P> where
        P: Send,
        T: Send, 

    impl<T, P> Sync for Punctuated<T, P> where
        P: Sync,
        T: Sync, 

    impl<T, P> Unpin for Punctuated<T, P> where
        P: Unpin,
        T: Unpin, 

    impl<T, P> UnwindSafe for Punctuated<T, P> where
        P: UnwindSafe,
        T: UnwindSafe, 

    Blanket Implementations

    impl<T> Any for T where
        T: 'static + ?Sized,     [src]

    impl<T> Borrow<T> for T where
        T: ?Sized,     [src]

    impl<T> BorrowMut<T> for T where
        T: ?Sized,     [src]

    impl<T> From<T> for T[src]

    impl<T, U> Into<U> for T where
        U: From<T>,     [src]

    impl<T> Spanned for T where
        T: Spanned + ?Sized,     [src]

    impl<T> ToOwned for T where
        T: Clone,     [src]

    type Owned = T

    The resulting type after obtaining ownership.

    -

    impl<T> ToOwned for T where
        T: Clone,     [src]

    type Owned = T

    The resulting type after obtaining ownership.

    +

    impl<T, U> TryFrom<U> for T where
        U: Into<T>,     [src]

    type Error = Infallible

    The type returned in the event of a conversion error.

    -

    impl<T, U> TryInto<U> for T where
        U: TryFrom<T>,     [src]

    type Error = <U as TryFrom<T>>::Error

    The type returned in the event of a conversion error.

    -
    \ No newline at end of file +

    impl<T, U> TryFrom<U> for T where
        U: Into<T>,     [src]

    type Error = Infallible

    The type returned in the event of a conversion error.

    +

    impl<T, U> TryInto<U> for T where
        U: TryFrom<T>,     [src]

    type Error = <U as TryFrom<T>>::Error

    The type returned in the event of a conversion error.

    +
    + \ No newline at end of file diff --git a/syn/spanned/index.html b/syn/spanned/index.html index e1c403d..0697c1b 100644 --- a/syn/spanned/index.html +++ b/syn/spanned/index.html @@ -1,7 +1,7 @@ -syn::spanned - Rust +syn::spanned - Rust -

    [−][src]Module syn::spanned

    A trait that can provide the Span of the complete contents of a syntax +

    Module syn::spanned[−][src]

    A trait that can provide the Span of the complete contents of a syntax tree node.

    This module is available only if Syn is built with both the "parsing" and "printing" features.

    @@ -34,7 +34,7 @@ static assertion that Sync is implemented for that type.

    /* ... */ }

    By inserting this assert_sync fragment into the output code generated by -our macro, the user's code will fail to compile if ty does not implement +our macro, the user’s code will fail to compile if ty does not implement Sync. The errors they would see look like the following.

    error[E0277]: the trait bound `*const i32: std::marker::Sync` is not satisfied
   --> src/main.rs:10:21
@@ -42,7 +42,7 @@ our macro, the user's code will fail to compile if ty does not impl
 10 |     bad_field: *const i32,
    |                ^^^^^^^^^^ `*const i32` cannot be shared between threads safely
    -

    In this technique, using the Type's span for the error message makes the +

    In this technique, using the Type’s span for the error message makes the error appear in the correct place underlining the right type.


    Limitations

    @@ -57,4 +57,5 @@ needing the unstable join.

    Traits

    Spanned

    A trait that can provide the Span of the complete contents of a syntax tree node.

    -
    \ No newline at end of file +
    + \ No newline at end of file diff --git a/syn/spanned/trait.Spanned.html b/syn/spanned/trait.Spanned.html index bfa8276..0083c3b 100644 --- a/syn/spanned/trait.Spanned.html +++ b/syn/spanned/trait.Spanned.html @@ -1,7 +1,7 @@ -syn::spanned::Spanned - Rust +syn::spanned::Spanned - Rust -

    [−][src]Trait syn::spanned::Spanned

    pub trait Spanned {
+
    Trait syn::spanned::Spanned[−][src]
    pub trait Spanned {
     fn span(&self) -> Span;
 }
    A trait that can provide the Span of the complete contents of a syntax
 tree node.
    
@@ -12,4 +12,5 @@ tree node.
    
 "printing" features.
    
 
    Required methods
    fn span(&self) -> Span[src]
    Returns a Span covering the complete contents of this syntax tree
 node, or Span::call_site() if this node is empty.
    
-
    Loading content...
    Implementors
    impl<T: ?Sized + ToTokens> Spanned for T[src]
    Loading content...
    
\ No newline at end of file
+
    Loading content...

    Implementors

    impl<T: ?Sized + ToTokens> Spanned for T[src]

    Loading content...
    + \ No newline at end of file diff --git a/syn/struct.Abi.html b/syn/struct.Abi.html index 0dfab61..29faef9 100644 --- a/syn/struct.Abi.html +++ b/syn/struct.Abi.html @@ -1,7 +1,7 @@ -syn::Abi - Rust +syn::Abi - Rust -

    [−][src]Struct syn::Abi

    pub struct Abi {
+
    Struct syn::Abi[−][src]
    pub struct Abi {
     pub extern_token: Extern,
     pub name: Option<LitStr>,
 }
    The binary interface of a function: extern "C".
    
@@ -9,29 +9,30 @@
 feature.
    
 
    
                        Fields
    extern_token: Externname: Option<LitStr>
    Trait Implementations
    impl Clone for Abi[src]
    impl Debug for Abi[src]
    impl Eq for Abi[src]
    impl Hash for Abi[src]
    impl Parse for Abi[src]
    impl PartialEq<Abi> for Abi[src]
    impl Parse for Abi[src]
    impl PartialEq<Abi> for Abi[src]
    impl ToTokens for Abi[src]
    Auto Trait Implementations
    impl RefUnwindSafe for Abi[src]
    impl !Send for Abi[src]
    impl !Sync for Abi[src]
    impl Unpin for Abi[src]
    impl UnwindSafe for Abi[src]
    Blanket Implementations
    impl<T> Any for T where
        T: 'static + ?Sized,     [src]
    impl<T> Borrow<T> for T where
        T: ?Sized,     [src]
    impl<T> BorrowMut<T> for T where
        T: ?Sized,     [src]
    impl<T> From<T> for T[src]
    impl<T, U> Into<U> for T where
        U: From<T>,     [src]
    impl ToTokens for Abi[src]
    Auto Trait Implementations
    impl RefUnwindSafe for Abi
    impl !Send for Abi
    impl !Sync for Abi
    impl Unpin for Abi
    impl UnwindSafe for Abi
    Blanket Implementations
    impl<T> Any for T where
        T: 'static + ?Sized,     [src]
    impl<T> Borrow<T> for T where
        T: ?Sized,     [src]
    impl<T> BorrowMut<T> for T where
        T: ?Sized,     [src]
    impl<T> From<T> for T[src]
    impl<T, U> Into<U> for T where
        U: From<T>,     [src]
    impl<T> Spanned for T where
        T: Spanned + ?Sized,     [src]
    impl<T> ToOwned for T where
        T: Clone,     [src]
    type Owned = T
    The resulting type after obtaining ownership.
    
-
    impl<T> ToOwned for T where
        T: Clone,     [src]
    type Owned = T
    The resulting type after obtaining ownership.
    
+
    impl<T, U> TryFrom<U> for T where
        U: Into<T>,     [src]
    type Error = Infallible
    The type returned in the event of a conversion error.
    
-
    impl<T, U> TryInto<U> for T where
        U: TryFrom<T>,     [src]
    type Error = <U as TryFrom<T>>::Error
    The type returned in the event of a conversion error.
    
-
    
\ No newline at end of file
+

    impl<T, U> TryFrom<U> for T where
        U: Into<T>,     [src]

    type Error = Infallible

    The type returned in the event of a conversion error.

    +

    impl<T, U> TryInto<U> for T where
        U: TryFrom<T>,     [src]

    type Error = <U as TryFrom<T>>::Error

    The type returned in the event of a conversion error.

    +
    + \ No newline at end of file diff --git a/syn/struct.AngleBracketedGenericArguments.html b/syn/struct.AngleBracketedGenericArguments.html index 1e8ec02..114f873 100644 --- a/syn/struct.AngleBracketedGenericArguments.html +++ b/syn/struct.AngleBracketedGenericArguments.html @@ -1,7 +1,7 @@ -syn::AngleBracketedGenericArguments - Rust +syn::AngleBracketedGenericArguments - Rust -

    [−][src]Struct syn::AngleBracketedGenericArguments

    pub struct AngleBracketedGenericArguments {
+
    Struct syn::AngleBracketedGenericArguments[−][src]
    pub struct AngleBracketedGenericArguments {
     pub colon2_token: Option<Colon2>,
     pub lt_token: Lt,
     pub args: Punctuated<GenericArgument, Comma>,
@@ -11,29 +11,30 @@
 feature.
    
 
    
                        Fields
    colon2_token: Option<Colon2>lt_token: Ltargs: Punctuated<GenericArgument, Comma>gt_token: Gt
    Trait Implementations
    impl Clone for AngleBracketedGenericArguments[src]
    impl Debug for AngleBracketedGenericArguments[src]
    impl Eq for AngleBracketedGenericArguments[src]
    impl Hash for AngleBracketedGenericArguments[src]
    impl Parse for AngleBracketedGenericArguments[src]
    impl PartialEq<AngleBracketedGenericArguments> for AngleBracketedGenericArguments[src]
    impl Parse for AngleBracketedGenericArguments[src]
    impl PartialEq<AngleBracketedGenericArguments> for AngleBracketedGenericArguments[src]
    impl ToTokens for AngleBracketedGenericArguments[src]
    Auto Trait Implementations
    Blanket Implementations
    impl<T> Any for T where
        T: 'static + ?Sized,     [src]
    impl<T> Borrow<T> for T where
        T: ?Sized,     [src]
    impl<T> BorrowMut<T> for T where
        T: ?Sized,     [src]
    impl<T> From<T> for T[src]
    impl<T, U> Into<U> for T where
        U: From<T>,     [src]
    impl ToTokens for AngleBracketedGenericArguments[src]
    Auto Trait Implementations
    Blanket Implementations
    impl<T> Any for T where
        T: 'static + ?Sized,     [src]
    impl<T> Borrow<T> for T where
        T: ?Sized,     [src]
    impl<T> BorrowMut<T> for T where
        T: ?Sized,     [src]
    impl<T> From<T> for T[src]
    impl<T, U> Into<U> for T where
        U: From<T>,     [src]
    impl<T> Spanned for T where
        T: Spanned + ?Sized,     [src]
    impl<T> ToOwned for T where
        T: Clone,     [src]
    type Owned = T
    The resulting type after obtaining ownership.
    
-
    impl<T> ToOwned for T where
        T: Clone,     [src]
    type Owned = T
    The resulting type after obtaining ownership.
    
+
    impl<T, U> TryFrom<U> for T where
        U: Into<T>,     [src]
    type Error = Infallible
    The type returned in the event of a conversion error.
    
-
    impl<T, U> TryInto<U> for T where
        U: TryFrom<T>,     [src]
    type Error = <U as TryFrom<T>>::Error
    The type returned in the event of a conversion error.
    
-
    
\ No newline at end of file
+

    impl<T, U> TryFrom<U> for T where
        U: Into<T>,     [src]

    type Error = Infallible

    The type returned in the event of a conversion error.

    +

    impl<T, U> TryInto<U> for T where
        U: TryFrom<T>,     [src]

    type Error = <U as TryFrom<T>>::Error

    The type returned in the event of a conversion error.

    +
    + \ No newline at end of file diff --git a/syn/struct.Attribute.html b/syn/struct.Attribute.html index 6c31c8d..ea10d07 100644 --- a/syn/struct.Attribute.html +++ b/syn/struct.Attribute.html @@ -1,7 +1,7 @@ -syn::Attribute - Rust +syn::Attribute - Rust -

    [−][src]Struct syn::Attribute

    pub struct Attribute {
+
    Struct syn::Attribute[−][src]
    pub struct Attribute {
     pub pound_token: Pound,
     pub style: AttrStyle,
     pub bracket_token: Bracket,
@@ -114,7 +114,7 @@ expanded into an attribute of the form #[doc = r"comment"]assert_eq!(doc, attr);

    - Fields

    pound_token: Poundstyle: AttrStylebracket_token: Bracketpath: Pathtokens: TokenStream

    Implementations

    impl Attribute[src]

    pub fn parse_meta(&self) -> Result<Meta>[src]

    Parses the content of the attribute, consisting of the path and tokens, + Fieldspound_token: Poundstyle: AttrStylebracket_token: Bracketpath: Pathtokens: TokenStream

    Implementations

    impl Attribute[src]

    pub fn parse_meta(&self) -> Result<Meta>[src]

    Parses the content of the attribute, consisting of the path and tokens, as a Meta if possible.

    This function is available only if Syn is built with the "parsing" feature.

    @@ -136,33 +136,34 @@ feature.

    pub fn parse_outer(input: ParseStream<'_>) -> Result<Vec<Self>>[src]

    Parses zero or more outer attributes from the stream.

    This function is available only if Syn is built with the "parsing" feature.

    -

    pub fn parse_inner(input: ParseStream<'_>) -> Result<Vec<Self>>[src]

    Parses zero or more inner attributes from the stream.

    +

    pub fn parse_inner(input: ParseStream<'_>) -> Result<Vec<Self>>[src]

    Parses zero or more inner attributes from the stream.

    This function is available only if Syn is built with the "parsing" feature.

    Trait Implementations

    impl Clone for Attribute[src]

    impl Debug for Attribute[src]

    impl Eq for Attribute[src]

    impl Hash for Attribute[src]

    impl PartialEq<Attribute> for Attribute[src]

    impl ToTokens for Attribute[src]

    Auto Trait Implementations

    Blanket Implementations

    impl<T> Any for T where
        T: 'static + ?Sized,     [src]

    impl<T> Borrow<T> for T where
        T: ?Sized,     [src]

    impl<T> BorrowMut<T> for T where
        T: ?Sized,     [src]

    impl<T> From<T> for T[src]

    impl<T, U> Into<U> for T where
        U: From<T>,     [src]

    impl ToTokens for Attribute[src]

    Auto Trait Implementations

    Blanket Implementations

    impl<T> Any for T where
        T: 'static + ?Sized,     [src]

    impl<T> Borrow<T> for T where
        T: ?Sized,     [src]

    impl<T> BorrowMut<T> for T where
        T: ?Sized,     [src]

    impl<T> From<T> for T[src]

    impl<T, U> Into<U> for T where
        U: From<T>,     [src]

    impl<T> Spanned for T where
        T: Spanned + ?Sized,     [src]

    impl<T> ToOwned for T where
        T: Clone,     [src]

    type Owned = T

    The resulting type after obtaining ownership.

    -

    impl<T> ToOwned for T where
        T: Clone,     [src]

    type Owned = T

    The resulting type after obtaining ownership.

    +

    impl<T, U> TryFrom<U> for T where
        U: Into<T>,     [src]

    type Error = Infallible

    The type returned in the event of a conversion error.

    -

    impl<T, U> TryInto<U> for T where
        U: TryFrom<T>,     [src]

    type Error = <U as TryFrom<T>>::Error

    The type returned in the event of a conversion error.

    -
    \ No newline at end of file +

    impl<T, U> TryFrom<U> for T where
        U: Into<T>,     [src]

    type Error = Infallible

    The type returned in the event of a conversion error.

    +

    impl<T, U> TryInto<U> for T where
        U: TryFrom<T>,     [src]

    type Error = <U as TryFrom<T>>::Error

    The type returned in the event of a conversion error.

    +
    + \ No newline at end of file diff --git a/syn/struct.BareFnArg.html b/syn/struct.BareFnArg.html index 9eef0eb..65d9dea 100644 --- a/syn/struct.BareFnArg.html +++ b/syn/struct.BareFnArg.html @@ -1,7 +1,7 @@ -syn::BareFnArg - Rust +syn::BareFnArg - Rust -

    [−][src]Struct syn::BareFnArg

    pub struct BareFnArg {
+
    Struct syn::BareFnArg[−][src]
    pub struct BareFnArg {
     pub attrs: Vec<Attribute>,
     pub name: Option<(Ident, Colon)>,
     pub ty: Type,
@@ -10,29 +10,30 @@
 feature.
    
 
    
                        Fields
    attrs: Vec<Attribute>name: Option<(Ident, Colon)>ty: Type
    Trait Implementations
    impl Clone for BareFnArg[src]
    impl Debug for BareFnArg[src]
    impl Eq for BareFnArg[src]
    impl Hash for BareFnArg[src]
    impl Parse for BareFnArg[src]
    impl PartialEq<BareFnArg> for BareFnArg[src]
    impl Parse for BareFnArg[src]
    impl PartialEq<BareFnArg> for BareFnArg[src]
    impl ToTokens for BareFnArg[src]
    Auto Trait Implementations
    Blanket Implementations
    impl<T> Any for T where
        T: 'static + ?Sized,     [src]
    impl<T> Borrow<T> for T where
        T: ?Sized,     [src]
    impl<T> BorrowMut<T> for T where
        T: ?Sized,     [src]
    impl<T> From<T> for T[src]
    impl<T, U> Into<U> for T where
        U: From<T>,     [src]
    impl ToTokens for BareFnArg[src]
    Auto Trait Implementations
    Blanket Implementations
    impl<T> Any for T where
        T: 'static + ?Sized,     [src]
    impl<T> Borrow<T> for T where
        T: ?Sized,     [src]
    impl<T> BorrowMut<T> for T where
        T: ?Sized,     [src]
    impl<T> From<T> for T[src]
    impl<T, U> Into<U> for T where
        U: From<T>,     [src]
    impl<T> Spanned for T where
        T: Spanned + ?Sized,     [src]
    impl<T> ToOwned for T where
        T: Clone,     [src]
    type Owned = T
    The resulting type after obtaining ownership.
    
-
    impl<T> ToOwned for T where
        T: Clone,     [src]
    type Owned = T
    The resulting type after obtaining ownership.
    
+
    impl<T, U> TryFrom<U> for T where
        U: Into<T>,     [src]
    type Error = Infallible
    The type returned in the event of a conversion error.
    
-
    impl<T, U> TryInto<U> for T where
        U: TryFrom<T>,     [src]
    type Error = <U as TryFrom<T>>::Error
    The type returned in the event of a conversion error.
    
-
    
\ No newline at end of file
+

    impl<T, U> TryFrom<U> for T where
        U: Into<T>,     [src]

    type Error = Infallible

    The type returned in the event of a conversion error.

    +

    impl<T, U> TryInto<U> for T where
        U: TryFrom<T>,     [src]

    type Error = <U as TryFrom<T>>::Error

    The type returned in the event of a conversion error.

    +
    + \ No newline at end of file diff --git a/syn/struct.Binding.html b/syn/struct.Binding.html index 1300972..858f8ba 100644 --- a/syn/struct.Binding.html +++ b/syn/struct.Binding.html @@ -1,7 +1,7 @@ -syn::Binding - Rust +syn::Binding - Rust -

    [−][src]Struct syn::Binding

    pub struct Binding {
+
    Struct syn::Binding[−][src]
    pub struct Binding {
     pub ident: Ident,
     pub eq_token: Eq,
     pub ty: Type,
@@ -10,29 +10,30 @@
 feature.
    
 
    
                        Fields
    ident: Identeq_token: Eqty: Type
    Trait Implementations
    impl Clone for Binding[src]
    impl Debug for Binding[src]
    impl Eq for Binding[src]
    impl Hash for Binding[src]
    impl Parse for Binding[src]
    impl PartialEq<Binding> for Binding[src]
    impl Parse for Binding[src]
    impl PartialEq<Binding> for Binding[src]
    impl ToTokens for Binding[src]
    Auto Trait Implementations
    Blanket Implementations
    impl<T> Any for T where
        T: 'static + ?Sized,     [src]
    impl<T> Borrow<T> for T where
        T: ?Sized,     [src]
    impl<T> BorrowMut<T> for T where
        T: ?Sized,     [src]
    impl<T> From<T> for T[src]
    impl<T, U> Into<U> for T where
        U: From<T>,     [src]
    impl ToTokens for Binding[src]
    Auto Trait Implementations
    impl RefUnwindSafe for Binding
    impl !Send for Binding
    impl !Sync for Binding
    impl Unpin for Binding
    impl UnwindSafe for Binding
    Blanket Implementations
    impl<T> Any for T where
        T: 'static + ?Sized,     [src]
    impl<T> Borrow<T> for T where
        T: ?Sized,     [src]
    impl<T> BorrowMut<T> for T where
        T: ?Sized,     [src]
    impl<T> From<T> for T[src]
    impl<T, U> Into<U> for T where
        U: From<T>,     [src]
    impl<T> Spanned for T where
        T: Spanned + ?Sized,     [src]
    impl<T> ToOwned for T where
        T: Clone,     [src]
    type Owned = T
    The resulting type after obtaining ownership.
    
-
    impl<T> ToOwned for T where
        T: Clone,     [src]
    type Owned = T
    The resulting type after obtaining ownership.
    
+
    impl<T, U> TryFrom<U> for T where
        U: Into<T>,     [src]
    type Error = Infallible
    The type returned in the event of a conversion error.
    
-
    impl<T, U> TryInto<U> for T where
        U: TryFrom<T>,     [src]
    type Error = <U as TryFrom<T>>::Error
    The type returned in the event of a conversion error.
    
-
    
\ No newline at end of file
+

    impl<T, U> TryFrom<U> for T where
        U: Into<T>,     [src]

    type Error = Infallible

    The type returned in the event of a conversion error.

    +

    impl<T, U> TryInto<U> for T where
        U: TryFrom<T>,     [src]

    type Error = <U as TryFrom<T>>::Error

    The type returned in the event of a conversion error.

    +
    + \ No newline at end of file diff --git a/syn/struct.BoundLifetimes.html b/syn/struct.BoundLifetimes.html index 3067eba..6c14c79 100644 --- a/syn/struct.BoundLifetimes.html +++ b/syn/struct.BoundLifetimes.html @@ -1,7 +1,7 @@ -syn::BoundLifetimes - Rust +syn::BoundLifetimes - Rust -

    [−][src]Struct syn::BoundLifetimes

    pub struct BoundLifetimes {
+
    Struct syn::BoundLifetimes[−][src]
    pub struct BoundLifetimes {
     pub for_token: For,
     pub lt_token: Lt,
     pub lifetimes: Punctuated<LifetimeDef, Comma>,
@@ -11,30 +11,31 @@
 feature.
    
 
    
                        Fields
    for_token: Forlt_token: Ltlifetimes: Punctuated<LifetimeDef, Comma>gt_token: Gt
    Trait Implementations
    impl Clone for BoundLifetimes[src]
    impl Debug for BoundLifetimes[src]
    impl Default for BoundLifetimes[src]
    impl Default for BoundLifetimes[src]
    impl Eq for BoundLifetimes[src]
    impl Hash for BoundLifetimes[src]
    impl Parse for BoundLifetimes[src]
    impl PartialEq<BoundLifetimes> for BoundLifetimes[src]
    impl Parse for BoundLifetimes[src]
    impl PartialEq<BoundLifetimes> for BoundLifetimes[src]
    impl ToTokens for BoundLifetimes[src]
    Auto Trait Implementations
    Blanket Implementations
    impl<T> Any for T where
        T: 'static + ?Sized,     [src]
    impl<T> Borrow<T> for T where
        T: ?Sized,     [src]
    impl<T> BorrowMut<T> for T where
        T: ?Sized,     [src]
    impl<T> From<T> for T[src]
    impl<T, U> Into<U> for T where
        U: From<T>,     [src]
    impl ToTokens for BoundLifetimes[src]
    Auto Trait Implementations
    Blanket Implementations
    impl<T> Any for T where
        T: 'static + ?Sized,     [src]
    impl<T> Borrow<T> for T where
        T: ?Sized,     [src]
    impl<T> BorrowMut<T> for T where
        T: ?Sized,     [src]
    impl<T> From<T> for T[src]
    impl<T, U> Into<U> for T where
        U: From<T>,     [src]
    impl<T> Spanned for T where
        T: Spanned + ?Sized,     [src]
    impl<T> ToOwned for T where
        T: Clone,     [src]
    type Owned = T
    The resulting type after obtaining ownership.
    
-
    impl<T> ToOwned for T where
        T: Clone,     [src]
    type Owned = T
    The resulting type after obtaining ownership.
    
+
    impl<T, U> TryFrom<U> for T where
        U: Into<T>,     [src]
    type Error = Infallible
    The type returned in the event of a conversion error.
    
-
    impl<T, U> TryInto<U> for T where
        U: TryFrom<T>,     [src]
    type Error = <U as TryFrom<T>>::Error
    The type returned in the event of a conversion error.
    
-
    
\ No newline at end of file
+

    impl<T, U> TryFrom<U> for T where
        U: Into<T>,     [src]

    type Error = Infallible

    The type returned in the event of a conversion error.

    +

    impl<T, U> TryInto<U> for T where
        U: TryFrom<T>,     [src]

    type Error = <U as TryFrom<T>>::Error

    The type returned in the event of a conversion error.

    +
    + \ No newline at end of file diff --git a/syn/struct.ConstParam.html b/syn/struct.ConstParam.html index 9ec4a08..b592dea 100644 --- a/syn/struct.ConstParam.html +++ b/syn/struct.ConstParam.html @@ -1,7 +1,7 @@ -syn::ConstParam - Rust +syn::ConstParam - Rust -

    [−][src]Struct syn::ConstParam

    pub struct ConstParam {
+
    Struct syn::ConstParam[−][src]
    pub struct ConstParam {
     pub attrs: Vec<Attribute>,
     pub const_token: Const,
     pub ident: Ident,
@@ -14,30 +14,31 @@
 "full" feature.
    
 
    
                        Fields
    attrs: Vec<Attribute>const_token: Constident: Identcolon_token: Colonty: Typeeq_token: Option<Eq>default: Option<Expr>
    Trait Implementations
    impl Clone for ConstParam[src]
    impl Debug for ConstParam[src]
    impl Eq for ConstParam[src]
    impl From<ConstParam> for GenericParam[src]
    impl Hash for ConstParam[src]
    impl Parse for ConstParam[src]
    impl PartialEq<ConstParam> for ConstParam[src]
    impl Parse for ConstParam[src]
    impl PartialEq<ConstParam> for ConstParam[src]
    impl ToTokens for ConstParam[src]
    Auto Trait Implementations
    Blanket Implementations
    impl<T> Any for T where
        T: 'static + ?Sized,     [src]
    impl<T> Borrow<T> for T where
        T: ?Sized,     [src]
    impl<T> BorrowMut<T> for T where
        T: ?Sized,     [src]
    impl<T> From<T> for T[src]
    impl<T, U> Into<U> for T where
        U: From<T>,     [src]
    impl ToTokens for ConstParam[src]
    Auto Trait Implementations
    Blanket Implementations
    impl<T> Any for T where
        T: 'static + ?Sized,     [src]
    impl<T> Borrow<T> for T where
        T: ?Sized,     [src]
    impl<T> BorrowMut<T> for T where
        T: ?Sized,     [src]
    impl<T> From<T> for T[src]
    impl<T, U> Into<U> for T where
        U: From<T>,     [src]
    impl<T> Spanned for T where
        T: Spanned + ?Sized,     [src]
    impl<T> ToOwned for T where
        T: Clone,     [src]
    type Owned = T
    The resulting type after obtaining ownership.
    
-
    impl<T> ToOwned for T where
        T: Clone,     [src]
    type Owned = T
    The resulting type after obtaining ownership.
    
+
    impl<T, U> TryFrom<U> for T where
        U: Into<T>,     [src]
    type Error = Infallible
    The type returned in the event of a conversion error.
    
-
    impl<T, U> TryInto<U> for T where
        U: TryFrom<T>,     [src]
    type Error = <U as TryFrom<T>>::Error
    The type returned in the event of a conversion error.
    
-
    
\ No newline at end of file
+

    impl<T, U> TryFrom<U> for T where
        U: Into<T>,     [src]

    type Error = Infallible

    The type returned in the event of a conversion error.

    +

    impl<T, U> TryInto<U> for T where
        U: TryFrom<T>,     [src]

    type Error = <U as TryFrom<T>>::Error

    The type returned in the event of a conversion error.

    +
    + \ No newline at end of file diff --git a/syn/struct.Constraint.html b/syn/struct.Constraint.html index 6211f13..fa50be1 100644 --- a/syn/struct.Constraint.html +++ b/syn/struct.Constraint.html @@ -1,7 +1,7 @@ -syn::Constraint - Rust +syn::Constraint - Rust -

    [−][src]Struct syn::Constraint

    pub struct Constraint {
+
    Struct syn::Constraint[−][src]
    pub struct Constraint {
     pub ident: Ident,
     pub colon_token: Colon,
     pub bounds: Punctuated<TypeParamBound, Add>,
@@ -10,29 +10,30 @@
 feature.
    
 
    
                        Fields
    ident: Identcolon_token: Colonbounds: Punctuated<TypeParamBound, Add>
    Trait Implementations
    impl Clone for Constraint[src]
    impl Debug for Constraint[src]
    impl Eq for Constraint[src]
    impl Hash for Constraint[src]
    impl PartialEq<Constraint> for Constraint[src]
    impl ToTokens for Constraint[src]
    Auto Trait Implementations
    Blanket Implementations
    impl<T> Any for T where
        T: 'static + ?Sized,     [src]
    impl<T> Borrow<T> for T where
        T: ?Sized,     [src]
    impl<T> BorrowMut<T> for T where
        T: ?Sized,     [src]
    impl<T> From<T> for T[src]
    impl<T, U> Into<U> for T where
        U: From<T>,     [src]
    impl ToTokens for Constraint[src]
    Auto Trait Implementations
    Blanket Implementations
    impl<T> Any for T where
        T: 'static + ?Sized,     [src]
    impl<T> Borrow<T> for T where
        T: ?Sized,     [src]
    impl<T> BorrowMut<T> for T where
        T: ?Sized,     [src]
    impl<T> From<T> for T[src]
    impl<T, U> Into<U> for T where
        U: From<T>,     [src]
    impl<T> Spanned for T where
        T: Spanned + ?Sized,     [src]
    impl<T> ToOwned for T where
        T: Clone,     [src]
    type Owned = T
    The resulting type after obtaining ownership.
    
-
    impl<T> ToOwned for T where
        T: Clone,     [src]
    type Owned = T
    The resulting type after obtaining ownership.
    
+
    impl<T, U> TryFrom<U> for T where
        U: Into<T>,     [src]
    type Error = Infallible
    The type returned in the event of a conversion error.
    
-
    impl<T, U> TryInto<U> for T where
        U: TryFrom<T>,     [src]
    type Error = <U as TryFrom<T>>::Error
    The type returned in the event of a conversion error.
    
-
    
\ No newline at end of file
+

    impl<T, U> TryFrom<U> for T where
        U: Into<T>,     [src]

    type Error = Infallible

    The type returned in the event of a conversion error.

    +

    impl<T, U> TryInto<U> for T where
        U: TryFrom<T>,     [src]

    type Error = <U as TryFrom<T>>::Error

    The type returned in the event of a conversion error.

    +
    + \ No newline at end of file diff --git a/syn/struct.DataEnum.html b/syn/struct.DataEnum.html index 585ed10..09f2141 100644 --- a/syn/struct.DataEnum.html +++ b/syn/struct.DataEnum.html @@ -1,7 +1,7 @@ -syn::DataEnum - Rust +syn::DataEnum - Rust -

    [−][src]Struct syn::DataEnum

    pub struct DataEnum {
+
    Struct syn::DataEnum[−][src]
    pub struct DataEnum {
     pub enum_token: Enum,
     pub brace_token: Brace,
     pub variants: Punctuated<Variant, Comma>,
@@ -10,25 +10,26 @@
 feature.
    
 
    
                        Fields
    enum_token: Enumbrace_token: Bracevariants: Punctuated<Variant, Comma>
    Trait Implementations
    impl Clone for DataEnum[src]
    impl Debug for DataEnum[src]
    impl Eq for DataEnum[src]
    impl From<DataEnum> for Data[src]
    impl Hash for DataEnum[src]
    impl PartialEq<DataEnum> for DataEnum[src]
    Auto Trait Implementations
    Blanket Implementations
    impl<T> Any for T where
        T: 'static + ?Sized,     [src]
    impl<T> Borrow<T> for T where
        T: ?Sized,     [src]
    impl<T> BorrowMut<T> for T where
        T: ?Sized,     [src]
    impl<T> From<T> for T[src]
    impl<T, U> Into<U> for T where
        U: From<T>,     [src]
    impl<T> ToOwned for T where
        T: Clone,     [src]
    type Owned = T
    The resulting type after obtaining ownership.
    
-
    Auto Trait Implementations
    impl RefUnwindSafe for DataEnum
    impl !Send for DataEnum
    impl !Sync for DataEnum
    impl Unpin for DataEnum
    impl UnwindSafe for DataEnum
    Blanket Implementations
    impl<T> Any for T where
        T: 'static + ?Sized,     [src]
    impl<T> Borrow<T> for T where
        T: ?Sized,     [src]
    impl<T> BorrowMut<T> for T where
        T: ?Sized,     [src]
    impl<T> From<T> for T[src]
    impl<T, U> Into<U> for T where
        U: From<T>,     [src]
    impl<T> ToOwned for T where
        T: Clone,     [src]
    type Owned = T
    The resulting type after obtaining ownership.
    
+
    impl<T, U> TryFrom<U> for T where
        U: Into<T>,     [src]
    type Error = Infallible
    The type returned in the event of a conversion error.
    
-
    impl<T, U> TryInto<U> for T where
        U: TryFrom<T>,     [src]
    type Error = <U as TryFrom<T>>::Error
    The type returned in the event of a conversion error.
    
-
    
\ No newline at end of file
+

    impl<T, U> TryFrom<U> for T where
        U: Into<T>,     [src]

    type Error = Infallible

    The type returned in the event of a conversion error.

    +

    impl<T, U> TryInto<U> for T where
        U: TryFrom<T>,     [src]

    type Error = <U as TryFrom<T>>::Error

    The type returned in the event of a conversion error.

    +
    + \ No newline at end of file diff --git a/syn/struct.DataStruct.html b/syn/struct.DataStruct.html index b12919f..67fd011 100644 --- a/syn/struct.DataStruct.html +++ b/syn/struct.DataStruct.html @@ -1,7 +1,7 @@ -syn::DataStruct - Rust +syn::DataStruct - Rust -

    [−][src]Struct syn::DataStruct

    pub struct DataStruct {
+
    Struct syn::DataStruct[−][src]
    pub struct DataStruct {
     pub struct_token: Struct,
     pub fields: Fields,
     pub semi_token: Option<Semi>,
@@ -10,25 +10,26 @@
 feature.
    
 
    
                        Fields
    struct_token: Structfields: Fieldssemi_token: Option<Semi>
    Trait Implementations
    impl Clone for DataStruct[src]
    impl Debug for DataStruct[src]
    impl Eq for DataStruct[src]
    impl From<DataStruct> for Data[src]
    impl Hash for DataStruct[src]
    impl PartialEq<DataStruct> for DataStruct[src]
    Auto Trait Implementations
    Blanket Implementations
    impl<T> Any for T where
        T: 'static + ?Sized,     [src]
    impl<T> Borrow<T> for T where
        T: ?Sized,     [src]
    impl<T> BorrowMut<T> for T where
        T: ?Sized,     [src]
    impl<T> From<T> for T[src]
    impl<T, U> Into<U> for T where
        U: From<T>,     [src]
    impl<T> ToOwned for T where
        T: Clone,     [src]
    type Owned = T
    The resulting type after obtaining ownership.
    
-
    Auto Trait Implementations
    Blanket Implementations
    impl<T> Any for T where
        T: 'static + ?Sized,     [src]
    impl<T> Borrow<T> for T where
        T: ?Sized,     [src]
    impl<T> BorrowMut<T> for T where
        T: ?Sized,     [src]
    impl<T> From<T> for T[src]
    impl<T, U> Into<U> for T where
        U: From<T>,     [src]
    impl<T> ToOwned for T where
        T: Clone,     [src]
    type Owned = T
    The resulting type after obtaining ownership.
    
+
    impl<T, U> TryFrom<U> for T where
        U: Into<T>,     [src]
    type Error = Infallible
    The type returned in the event of a conversion error.
    
-
    impl<T, U> TryInto<U> for T where
        U: TryFrom<T>,     [src]
    type Error = <U as TryFrom<T>>::Error
    The type returned in the event of a conversion error.
    
-
    
\ No newline at end of file
+

    impl<T, U> TryFrom<U> for T where
        U: Into<T>,     [src]

    type Error = Infallible

    The type returned in the event of a conversion error.

    +

    impl<T, U> TryInto<U> for T where
        U: TryFrom<T>,     [src]

    type Error = <U as TryFrom<T>>::Error

    The type returned in the event of a conversion error.

    +
    + \ No newline at end of file diff --git a/syn/struct.DataUnion.html b/syn/struct.DataUnion.html index fcb5f6a..d726d6b 100644 --- a/syn/struct.DataUnion.html +++ b/syn/struct.DataUnion.html @@ -1,7 +1,7 @@ -syn::DataUnion - Rust +syn::DataUnion - Rust -

    [−][src]Struct syn::DataUnion

    pub struct DataUnion {
+
    Struct syn::DataUnion[−][src]
    pub struct DataUnion {
     pub union_token: Union,
     pub fields: FieldsNamed,
 }
    An untagged union input to a proc_macro_derive macro.
    
@@ -9,25 +9,26 @@
 feature.
    
 
    
                        Fields
    union_token: Unionfields: FieldsNamed
    Trait Implementations
    impl Clone for DataUnion[src]
    impl Debug for DataUnion[src]
    impl Eq for DataUnion[src]
    impl From<DataUnion> for Data[src]
    impl Hash for DataUnion[src]
    impl PartialEq<DataUnion> for DataUnion[src]
    Auto Trait Implementations
    Blanket Implementations
    impl<T> Any for T where
        T: 'static + ?Sized,     [src]
    impl<T> Borrow<T> for T where
        T: ?Sized,     [src]
    impl<T> BorrowMut<T> for T where
        T: ?Sized,     [src]
    impl<T> From<T> for T[src]
    impl<T, U> Into<U> for T where
        U: From<T>,     [src]
    impl<T> ToOwned for T where
        T: Clone,     [src]
    type Owned = T
    The resulting type after obtaining ownership.
    
-
    Auto Trait Implementations
    Blanket Implementations
    impl<T> Any for T where
        T: 'static + ?Sized,     [src]
    impl<T> Borrow<T> for T where
        T: ?Sized,     [src]
    impl<T> BorrowMut<T> for T where
        T: ?Sized,     [src]
    impl<T> From<T> for T[src]
    impl<T, U> Into<U> for T where
        U: From<T>,     [src]
    impl<T> ToOwned for T where
        T: Clone,     [src]
    type Owned = T
    The resulting type after obtaining ownership.
    
+
    impl<T, U> TryFrom<U> for T where
        U: Into<T>,     [src]
    type Error = Infallible
    The type returned in the event of a conversion error.
    
-
    impl<T, U> TryInto<U> for T where
        U: TryFrom<T>,     [src]
    type Error = <U as TryFrom<T>>::Error
    The type returned in the event of a conversion error.
    
-
    
\ No newline at end of file
+

    impl<T, U> TryFrom<U> for T where
        U: Into<T>,     [src]

    type Error = Infallible

    The type returned in the event of a conversion error.

    +

    impl<T, U> TryInto<U> for T where
        U: TryFrom<T>,     [src]

    type Error = <U as TryFrom<T>>::Error

    The type returned in the event of a conversion error.

    +
    + \ No newline at end of file diff --git a/syn/struct.DeriveInput.html b/syn/struct.DeriveInput.html index 259c9cf..31bb406 100644 --- a/syn/struct.DeriveInput.html +++ b/syn/struct.DeriveInput.html @@ -1,7 +1,7 @@ -syn::DeriveInput - Rust +syn::DeriveInput - Rust -

    [−][src]Struct syn::DeriveInput

    pub struct DeriveInput {
+
    Struct syn::DeriveInput[−][src]
    pub struct DeriveInput {
     pub attrs: Vec<Attribute>,
     pub vis: Visibility,
     pub ident: Ident,
@@ -16,29 +16,30 @@
 
    generics: Generics
    Generics required to complete the definition.
    
 
    data: Data
    Data within the struct or enum.
    
 
    Trait Implementations
    impl Clone for DeriveInput[src]
    impl Debug for DeriveInput[src]
    impl Eq for DeriveInput[src]
    impl Hash for DeriveInput[src]
    impl Parse for DeriveInput[src]
    impl PartialEq<DeriveInput> for DeriveInput[src]
    impl ToTokens for DeriveInput[src]
    Auto Trait Implementations
    Blanket Implementations
    impl<T> Any for T where
        T: 'static + ?Sized,     [src]
    impl<T> Borrow<T> for T where
        T: ?Sized,     [src]
    impl<T> BorrowMut<T> for T where
        T: ?Sized,     [src]
    impl<T> From<T> for T[src]
    impl<T, U> Into<U> for T where
        U: From<T>,     [src]
    impl ToTokens for DeriveInput[src]
    Auto Trait Implementations
    Blanket Implementations
    impl<T> Any for T where
        T: 'static + ?Sized,     [src]
    impl<T> Borrow<T> for T where
        T: ?Sized,     [src]
    impl<T> BorrowMut<T> for T where
        T: ?Sized,     [src]
    impl<T> From<T> for T[src]
    impl<T, U> Into<U> for T where
        U: From<T>,     [src]
    impl<T> Spanned for T where
        T: Spanned + ?Sized,     [src]
    impl<T> ToOwned for T where
        T: Clone,     [src]
    type Owned = T
    The resulting type after obtaining ownership.
    
-
    impl<T> ToOwned for T where
        T: Clone,     [src]
    type Owned = T
    The resulting type after obtaining ownership.
    
+
    impl<T, U> TryFrom<U> for T where
        U: Into<T>,     [src]
    type Error = Infallible
    The type returned in the event of a conversion error.
    
-
    impl<T, U> TryInto<U> for T where
        U: TryFrom<T>,     [src]
    type Error = <U as TryFrom<T>>::Error
    The type returned in the event of a conversion error.
    
-
    
\ No newline at end of file
+

    impl<T, U> TryFrom<U> for T where
        U: Into<T>,     [src]

    type Error = Infallible

    The type returned in the event of a conversion error.

    +

    impl<T, U> TryInto<U> for T where
        U: TryFrom<T>,     [src]

    type Error = <U as TryFrom<T>>::Error

    The type returned in the event of a conversion error.

    +
    + \ No newline at end of file diff --git a/syn/struct.Error.html b/syn/struct.Error.html index 02dab25..11fa94d 100644 --- a/syn/struct.Error.html +++ b/syn/struct.Error.html @@ -1,7 +1,7 @@ -syn::Error - Rust +syn::Error - Rust -

    [−][src]Struct syn::Error

    pub struct Error { /* fields omitted */ }

    Error returned when a Syn parser cannot parse the input tokens.

    +

    Struct syn::Error[−][src]

    pub struct Error { /* fields omitted */ }

    Error returned when a Syn parser cannot parse the input tokens.

    Error reporting in proc macros

    The correct way to report errors back to the compiler from a procedural macro is by emitting an appropriately spanned invocation of @@ -68,7 +68,7 @@ typically be able to use the Spanned trait with the above Err constructor, implementation limitations today mean that Error::new_spanned may provide a higher-quality error message on stable Rust.

    -

    When in doubt it's recommended to stick to Error::new (or +

    When in doubt it’s recommended to stick to Error::new (or ParseStream::error)!

    pub fn span(&self) -> Span[src]

    The source location of the error.

    Spans are not thread-safe so this function returns Span::call_site() @@ -102,16 +102,16 @@ this method correctly in a procedural macro.

    pub fn combine(&mut self, another: Error)[src]

    Add another error message to self such that when to_compile_error() is called, both errors will be emitted together.

    Trait Implementations

    impl Clone for Error[src]

    impl Debug for Error[src]

    impl Display for Error[src]

    impl Error for Error[src]

    impl Error for Error[src]

    impl Extend<Error> for Error[src]

    impl From<LexError> for Error[src]

    impl IntoIterator for Error[src]

    type Item = Error

    The type of the elements being iterated over.

    type IntoIter = IntoIter

    Which kind of iterator are we turning this into?

    @@ -119,18 +119,19 @@ called, both errors will be emitted together.

    impl<'a> IntoIterator for &'a Error[src]

    type Item = Error

    The type of the elements being iterated over.

    type IntoIter = Iter<'a>

    Which kind of iterator are we turning this into?

    Auto Trait Implementations

    Blanket Implementations

    impl<T> Any for T where
        T: 'static + ?Sized,     [src]

    impl<T> Borrow<T> for T where
        T: ?Sized,     [src]

    impl<T> BorrowMut<T> for T where
        T: ?Sized,     [src]

    impl<T> From<T> for T[src]

    impl<T, U> Into<U> for T where
        U: From<T>,     [src]

    impl<T> ToOwned for T where
        T: Clone,     [src]

    type Owned = T

    The resulting type after obtaining ownership.

    -

    Auto Trait Implementations

    impl RefUnwindSafe for Error

    impl Send for Error

    impl Sync for Error

    impl Unpin for Error

    impl UnwindSafe for Error

    Blanket Implementations

    impl<T> Any for T where
        T: 'static + ?Sized,     [src]

    impl<T> Borrow<T> for T where
        T: ?Sized,     [src]

    impl<T> BorrowMut<T> for T where
        T: ?Sized,     [src]

    impl<T> From<T> for T[src]

    impl<T, U> Into<U> for T where
        U: From<T>,     [src]

    impl<T> ToOwned for T where
        T: Clone,     [src]

    type Owned = T

    The resulting type after obtaining ownership.

    +

    impl<T> ToString for T where
        T: Display + ?Sized,     [src]

    impl<T, U> TryFrom<U> for T where
        U: Into<T>,     [src]

    type Error = Infallible

    The type returned in the event of a conversion error.

    -

    impl<T, U> TryInto<U> for T where
        U: TryFrom<T>,     [src]

    type Error = <U as TryFrom<T>>::Error

    The type returned in the event of a conversion error.

    -
    \ No newline at end of file +

    impl<T> ToString for T where
        T: Display + ?Sized,     [src]

    impl<T, U> TryFrom<U> for T where
        U: Into<T>,     [src]

    type Error = Infallible

    The type returned in the event of a conversion error.

    +

    impl<T, U> TryInto<U> for T where
        U: TryFrom<T>,     [src]

    type Error = <U as TryFrom<T>>::Error

    The type returned in the event of a conversion error.

    +
    + \ No newline at end of file diff --git a/syn/struct.ExprArray.html b/syn/struct.ExprArray.html index 59a32c4..7ae4130 100644 --- a/syn/struct.ExprArray.html +++ b/syn/struct.ExprArray.html @@ -1,21 +1,22 @@ -syn::ExprArray - Rust +syn::ExprArray - Rust -

    [−][src]Struct syn::ExprArray

    pub struct ExprArray { /* fields omitted */ }

    A slice literal expression: [a, b, c, d].

    +

    Struct syn::ExprArray[−][src]

    pub struct ExprArray { /* fields omitted */ }

    A slice literal expression: [a, b, c, d].

    This type is available only if Syn is built with the "full" feature.

    Trait Implementations

    impl From<ExprArray> for Expr[src]

    impl ToTokens for ExprArray[src]

    Auto Trait Implementations

    Blanket Implementations

    impl<T> Any for T where
        T: 'static + ?Sized,     [src]

    impl<T> Borrow<T> for T where
        T: ?Sized,     [src]

    impl<T> BorrowMut<T> for T where
        T: ?Sized,     [src]

    impl<T> From<T> for T[src]

    impl<T, U> Into<U> for T where
        U: From<T>,     [src]

    Auto Trait Implementations

    Blanket Implementations

    impl<T> Any for T where
        T: 'static + ?Sized,     [src]

    impl<T> Borrow<T> for T where
        T: ?Sized,     [src]

    impl<T> BorrowMut<T> for T where
        T: ?Sized,     [src]

    impl<T> From<T> for T[src]

    impl<T, U> Into<U> for T where
        U: From<T>,     [src]

    impl<T> Spanned for T where
        T: Spanned + ?Sized,     [src]

    impl<T, U> TryFrom<U> for T where
        U: Into<T>,     [src]

    type Error = Infallible

    The type returned in the event of a conversion error.

    -

    impl<T, U> TryInto<U> for T where
        U: TryFrom<T>,     [src]

    type Error = <U as TryFrom<T>>::Error

    The type returned in the event of a conversion error.

    -
    \ No newline at end of file +

    impl<T, U> TryFrom<U> for T where
        U: Into<T>,     [src]

    type Error = Infallible

    The type returned in the event of a conversion error.

    +

    impl<T, U> TryInto<U> for T where
        U: TryFrom<T>,     [src]

    type Error = <U as TryFrom<T>>::Error

    The type returned in the event of a conversion error.

    +
    + \ No newline at end of file diff --git a/syn/struct.ExprAssign.html b/syn/struct.ExprAssign.html index 732c666..a574506 100644 --- a/syn/struct.ExprAssign.html +++ b/syn/struct.ExprAssign.html @@ -1,21 +1,22 @@ -syn::ExprAssign - Rust +syn::ExprAssign - Rust -

    [−][src]Struct syn::ExprAssign

    pub struct ExprAssign { /* fields omitted */ }

    An assignment expression: a = compute().

    +

    Struct syn::ExprAssign[−][src]

    pub struct ExprAssign { /* fields omitted */ }

    An assignment expression: a = compute().

    This type is available only if Syn is built with the "full" feature.

    Trait Implementations

    impl From<ExprAssign> for Expr[src]

    impl ToTokens for ExprAssign[src]

    Auto Trait Implementations

    Blanket Implementations

    impl<T> Any for T where
        T: 'static + ?Sized,     [src]

    impl<T> Borrow<T> for T where
        T: ?Sized,     [src]

    impl<T> BorrowMut<T> for T where
        T: ?Sized,     [src]

    impl<T> From<T> for T[src]

    impl<T, U> Into<U> for T where
        U: From<T>,     [src]

    Auto Trait Implementations

    Blanket Implementations

    impl<T> Any for T where
        T: 'static + ?Sized,     [src]

    impl<T> Borrow<T> for T where
        T: ?Sized,     [src]

    impl<T> BorrowMut<T> for T where
        T: ?Sized,     [src]

    impl<T> From<T> for T[src]

    impl<T, U> Into<U> for T where
        U: From<T>,     [src]

    impl<T> Spanned for T where
        T: Spanned + ?Sized,     [src]

    impl<T, U> TryFrom<U> for T where
        U: Into<T>,     [src]

    type Error = Infallible

    The type returned in the event of a conversion error.

    -

    impl<T, U> TryInto<U> for T where
        U: TryFrom<T>,     [src]

    type Error = <U as TryFrom<T>>::Error

    The type returned in the event of a conversion error.

    -
    \ No newline at end of file +

    impl<T, U> TryFrom<U> for T where
        U: Into<T>,     [src]

    type Error = Infallible

    The type returned in the event of a conversion error.

    +

    impl<T, U> TryInto<U> for T where
        U: TryFrom<T>,     [src]

    type Error = <U as TryFrom<T>>::Error

    The type returned in the event of a conversion error.

    +
    + \ No newline at end of file diff --git a/syn/struct.ExprAssignOp.html b/syn/struct.ExprAssignOp.html index cc36487..cb70da1 100644 --- a/syn/struct.ExprAssignOp.html +++ b/syn/struct.ExprAssignOp.html @@ -1,21 +1,22 @@ -syn::ExprAssignOp - Rust +syn::ExprAssignOp - Rust -

    [−][src]Struct syn::ExprAssignOp

    pub struct ExprAssignOp { /* fields omitted */ }

    A compound assignment expression: counter += 1.

    +

    Struct syn::ExprAssignOp[−][src]

    pub struct ExprAssignOp { /* fields omitted */ }

    A compound assignment expression: counter += 1.

    This type is available only if Syn is built with the "full" feature.

    Trait Implementations

    impl From<ExprAssignOp> for Expr[src]

    impl ToTokens for ExprAssignOp[src]

    Auto Trait Implementations

    Blanket Implementations

    impl<T> Any for T where
        T: 'static + ?Sized,     [src]

    impl<T> Borrow<T> for T where
        T: ?Sized,     [src]

    impl<T> BorrowMut<T> for T where
        T: ?Sized,     [src]

    impl<T> From<T> for T[src]

    impl<T, U> Into<U> for T where
        U: From<T>,     [src]

    Auto Trait Implementations

    Blanket Implementations

    impl<T> Any for T where
        T: 'static + ?Sized,     [src]

    impl<T> Borrow<T> for T where
        T: ?Sized,     [src]

    impl<T> BorrowMut<T> for T where
        T: ?Sized,     [src]

    impl<T> From<T> for T[src]

    impl<T, U> Into<U> for T where
        U: From<T>,     [src]

    impl<T> Spanned for T where
        T: Spanned + ?Sized,     [src]

    impl<T, U> TryFrom<U> for T where
        U: Into<T>,     [src]

    type Error = Infallible

    The type returned in the event of a conversion error.

    -

    impl<T, U> TryInto<U> for T where
        U: TryFrom<T>,     [src]

    type Error = <U as TryFrom<T>>::Error

    The type returned in the event of a conversion error.

    -
    \ No newline at end of file +

    impl<T, U> TryFrom<U> for T where
        U: Into<T>,     [src]

    type Error = Infallible

    The type returned in the event of a conversion error.

    +

    impl<T, U> TryInto<U> for T where
        U: TryFrom<T>,     [src]

    type Error = <U as TryFrom<T>>::Error

    The type returned in the event of a conversion error.

    +
    + \ No newline at end of file diff --git a/syn/struct.ExprAsync.html b/syn/struct.ExprAsync.html index 185830c..cae2b85 100644 --- a/syn/struct.ExprAsync.html +++ b/syn/struct.ExprAsync.html @@ -1,21 +1,22 @@ -syn::ExprAsync - Rust +syn::ExprAsync - Rust -

    [−][src]Struct syn::ExprAsync

    pub struct ExprAsync { /* fields omitted */ }

    An async block: async { ... }.

    +

    Struct syn::ExprAsync[−][src]

    pub struct ExprAsync { /* fields omitted */ }

    An async block: async { ... }.

    This type is available only if Syn is built with the "full" feature.

    Trait Implementations

    impl From<ExprAsync> for Expr[src]

    impl ToTokens for ExprAsync[src]

    Auto Trait Implementations

    Blanket Implementations

    impl<T> Any for T where
        T: 'static + ?Sized,     [src]

    impl<T> Borrow<T> for T where
        T: ?Sized,     [src]

    impl<T> BorrowMut<T> for T where
        T: ?Sized,     [src]

    impl<T> From<T> for T[src]

    impl<T, U> Into<U> for T where
        U: From<T>,     [src]

    Auto Trait Implementations

    Blanket Implementations

    impl<T> Any for T where
        T: 'static + ?Sized,     [src]

    impl<T> Borrow<T> for T where
        T: ?Sized,     [src]

    impl<T> BorrowMut<T> for T where
        T: ?Sized,     [src]

    impl<T> From<T> for T[src]

    impl<T, U> Into<U> for T where
        U: From<T>,     [src]

    impl<T> Spanned for T where
        T: Spanned + ?Sized,     [src]

    impl<T, U> TryFrom<U> for T where
        U: Into<T>,     [src]

    type Error = Infallible

    The type returned in the event of a conversion error.

    -

    impl<T, U> TryInto<U> for T where
        U: TryFrom<T>,     [src]

    type Error = <U as TryFrom<T>>::Error

    The type returned in the event of a conversion error.

    -
    \ No newline at end of file +

    impl<T, U> TryFrom<U> for T where
        U: Into<T>,     [src]

    type Error = Infallible

    The type returned in the event of a conversion error.

    +

    impl<T, U> TryInto<U> for T where
        U: TryFrom<T>,     [src]

    type Error = <U as TryFrom<T>>::Error

    The type returned in the event of a conversion error.

    +
    + \ No newline at end of file diff --git a/syn/struct.ExprAwait.html b/syn/struct.ExprAwait.html index d8f578f..e90aa91 100644 --- a/syn/struct.ExprAwait.html +++ b/syn/struct.ExprAwait.html @@ -1,21 +1,22 @@ -syn::ExprAwait - Rust +syn::ExprAwait - Rust -

    [−][src]Struct syn::ExprAwait

    pub struct ExprAwait { /* fields omitted */ }

    An await expression: fut.await.

    +

    Struct syn::ExprAwait[−][src]

    pub struct ExprAwait { /* fields omitted */ }

    An await expression: fut.await.

    This type is available only if Syn is built with the "full" feature.

    Trait Implementations

    impl From<ExprAwait> for Expr[src]

    impl ToTokens for ExprAwait[src]

    Auto Trait Implementations

    Blanket Implementations

    impl<T> Any for T where
        T: 'static + ?Sized,     [src]

    impl<T> Borrow<T> for T where
        T: ?Sized,     [src]

    impl<T> BorrowMut<T> for T where
        T: ?Sized,     [src]

    impl<T> From<T> for T[src]

    impl<T, U> Into<U> for T where
        U: From<T>,     [src]

    Auto Trait Implementations

    Blanket Implementations

    impl<T> Any for T where
        T: 'static + ?Sized,     [src]

    impl<T> Borrow<T> for T where
        T: ?Sized,     [src]

    impl<T> BorrowMut<T> for T where
        T: ?Sized,     [src]

    impl<T> From<T> for T[src]

    impl<T, U> Into<U> for T where
        U: From<T>,     [src]

    impl<T> Spanned for T where
        T: Spanned + ?Sized,     [src]

    impl<T, U> TryFrom<U> for T where
        U: Into<T>,     [src]

    type Error = Infallible

    The type returned in the event of a conversion error.

    -

    impl<T, U> TryInto<U> for T where
        U: TryFrom<T>,     [src]

    type Error = <U as TryFrom<T>>::Error

    The type returned in the event of a conversion error.

    -
    \ No newline at end of file +

    impl<T, U> TryFrom<U> for T where
        U: Into<T>,     [src]

    type Error = Infallible

    The type returned in the event of a conversion error.

    +

    impl<T, U> TryInto<U> for T where
        U: TryFrom<T>,     [src]

    type Error = <U as TryFrom<T>>::Error

    The type returned in the event of a conversion error.

    +
    + \ No newline at end of file diff --git a/syn/struct.ExprBinary.html b/syn/struct.ExprBinary.html index 85c16a7..3b14731 100644 --- a/syn/struct.ExprBinary.html +++ b/syn/struct.ExprBinary.html @@ -1,7 +1,7 @@ -syn::ExprBinary - Rust +syn::ExprBinary - Rust -

    [−][src]Struct syn::ExprBinary

    pub struct ExprBinary {
+
    Struct syn::ExprBinary[−][src]
    pub struct ExprBinary {
     pub attrs: Vec<Attribute>,
     pub left: Box<Expr>,
     pub op: BinOp,
@@ -11,30 +11,31 @@
 "full" feature.
    
 
    
                        Fields
    attrs: Vec<Attribute>left: Box<Expr>op: BinOpright: Box<Expr>
    Trait Implementations
    impl Clone for ExprBinary[src]
    impl Debug for ExprBinary[src]
    impl Eq for ExprBinary[src]
    impl From<ExprBinary> for Expr[src]
    impl Hash for ExprBinary[src]
    impl PartialEq<ExprBinary> for ExprBinary[src]
    impl ToTokens for ExprBinary[src]
    Auto Trait Implementations
    Blanket Implementations
    impl<T> Any for T where
        T: 'static + ?Sized,     [src]
    impl<T> Borrow<T> for T where
        T: ?Sized,     [src]
    impl<T> BorrowMut<T> for T where
        T: ?Sized,     [src]
    impl<T> From<T> for T[src]
    impl<T, U> Into<U> for T where
        U: From<T>,     [src]
    impl ToTokens for ExprBinary[src]
    Auto Trait Implementations
    Blanket Implementations
    impl<T> Any for T where
        T: 'static + ?Sized,     [src]
    impl<T> Borrow<T> for T where
        T: ?Sized,     [src]
    impl<T> BorrowMut<T> for T where
        T: ?Sized,     [src]
    impl<T> From<T> for T[src]
    impl<T, U> Into<U> for T where
        U: From<T>,     [src]
    impl<T> Spanned for T where
        T: Spanned + ?Sized,     [src]
    impl<T> ToOwned for T where
        T: Clone,     [src]
    type Owned = T
    The resulting type after obtaining ownership.
    
-
    impl<T> ToOwned for T where
        T: Clone,     [src]
    type Owned = T
    The resulting type after obtaining ownership.
    
+
    impl<T, U> TryFrom<U> for T where
        U: Into<T>,     [src]
    type Error = Infallible
    The type returned in the event of a conversion error.
    
-
    impl<T, U> TryInto<U> for T where
        U: TryFrom<T>,     [src]
    type Error = <U as TryFrom<T>>::Error
    The type returned in the event of a conversion error.
    
-
    
\ No newline at end of file
+

    impl<T, U> TryFrom<U> for T where
        U: Into<T>,     [src]

    type Error = Infallible

    The type returned in the event of a conversion error.

    +

    impl<T, U> TryInto<U> for T where
        U: TryFrom<T>,     [src]

    type Error = <U as TryFrom<T>>::Error

    The type returned in the event of a conversion error.

    +
    + \ No newline at end of file diff --git a/syn/struct.ExprBlock.html b/syn/struct.ExprBlock.html index 05fcaee..fc7f4eb 100644 --- a/syn/struct.ExprBlock.html +++ b/syn/struct.ExprBlock.html @@ -1,21 +1,22 @@ -syn::ExprBlock - Rust +syn::ExprBlock - Rust -

    [−][src]Struct syn::ExprBlock

    pub struct ExprBlock { /* fields omitted */ }

    A blocked scope: { ... }.

    +

    Struct syn::ExprBlock[−][src]

    pub struct ExprBlock { /* fields omitted */ }

    A blocked scope: { ... }.

    This type is available only if Syn is built with the "full" feature.

    Trait Implementations

    impl From<ExprBlock> for Expr[src]

    impl ToTokens for ExprBlock[src]

    Auto Trait Implementations

    Blanket Implementations

    impl<T> Any for T where
        T: 'static + ?Sized,     [src]

    impl<T> Borrow<T> for T where
        T: ?Sized,     [src]

    impl<T> BorrowMut<T> for T where
        T: ?Sized,     [src]

    impl<T> From<T> for T[src]

    impl<T, U> Into<U> for T where
        U: From<T>,     [src]

    Auto Trait Implementations

    Blanket Implementations

    impl<T> Any for T where
        T: 'static + ?Sized,     [src]

    impl<T> Borrow<T> for T where
        T: ?Sized,     [src]

    impl<T> BorrowMut<T> for T where
        T: ?Sized,     [src]

    impl<T> From<T> for T[src]

    impl<T, U> Into<U> for T where
        U: From<T>,     [src]

    impl<T> Spanned for T where
        T: Spanned + ?Sized,     [src]

    impl<T, U> TryFrom<U> for T where
        U: Into<T>,     [src]

    type Error = Infallible

    The type returned in the event of a conversion error.

    -

    impl<T, U> TryInto<U> for T where
        U: TryFrom<T>,     [src]

    type Error = <U as TryFrom<T>>::Error

    The type returned in the event of a conversion error.

    -
    \ No newline at end of file +

    impl<T, U> TryFrom<U> for T where
        U: Into<T>,     [src]

    type Error = Infallible

    The type returned in the event of a conversion error.

    +

    impl<T, U> TryInto<U> for T where
        U: TryFrom<T>,     [src]

    type Error = <U as TryFrom<T>>::Error

    The type returned in the event of a conversion error.

    +
    + \ No newline at end of file diff --git a/syn/struct.ExprBox.html b/syn/struct.ExprBox.html index a7cc0cb..ee59559 100644 --- a/syn/struct.ExprBox.html +++ b/syn/struct.ExprBox.html @@ -1,21 +1,22 @@ -syn::ExprBox - Rust +syn::ExprBox - Rust -

    [−][src]Struct syn::ExprBox

    pub struct ExprBox { /* fields omitted */ }

    A box expression: box f.

    +

    Struct syn::ExprBox[−][src]

    pub struct ExprBox { /* fields omitted */ }

    A box expression: box f.

    This type is available only if Syn is built with the "full" feature.

    Trait Implementations

    impl From<ExprBox> for Expr[src]

    impl ToTokens for ExprBox[src]

    Auto Trait Implementations

    Blanket Implementations

    impl<T> Any for T where
        T: 'static + ?Sized,     [src]

    impl<T> Borrow<T> for T where
        T: ?Sized,     [src]

    impl<T> BorrowMut<T> for T where
        T: ?Sized,     [src]

    impl<T> From<T> for T[src]

    impl<T, U> Into<U> for T where
        U: From<T>,     [src]

    Auto Trait Implementations

    impl RefUnwindSafe for ExprBox

    impl !Send for ExprBox

    impl !Sync for ExprBox

    impl Unpin for ExprBox

    impl UnwindSafe for ExprBox

    Blanket Implementations

    impl<T> Any for T where
        T: 'static + ?Sized,     [src]

    impl<T> Borrow<T> for T where
        T: ?Sized,     [src]

    impl<T> BorrowMut<T> for T where
        T: ?Sized,     [src]

    impl<T> From<T> for T[src]

    impl<T, U> Into<U> for T where
        U: From<T>,     [src]

    impl<T> Spanned for T where
        T: Spanned + ?Sized,     [src]

    impl<T, U> TryFrom<U> for T where
        U: Into<T>,     [src]

    type Error = Infallible

    The type returned in the event of a conversion error.

    -

    impl<T, U> TryInto<U> for T where
        U: TryFrom<T>,     [src]

    type Error = <U as TryFrom<T>>::Error

    The type returned in the event of a conversion error.

    -
    \ No newline at end of file +

    impl<T, U> TryFrom<U> for T where
        U: Into<T>,     [src]

    type Error = Infallible

    The type returned in the event of a conversion error.

    +

    impl<T, U> TryInto<U> for T where
        U: TryFrom<T>,     [src]

    type Error = <U as TryFrom<T>>::Error

    The type returned in the event of a conversion error.

    +
    + \ No newline at end of file diff --git a/syn/struct.ExprBreak.html b/syn/struct.ExprBreak.html index d8169ba..0de540f 100644 --- a/syn/struct.ExprBreak.html +++ b/syn/struct.ExprBreak.html @@ -1,22 +1,23 @@ -syn::ExprBreak - Rust +syn::ExprBreak - Rust -

    [−][src]Struct syn::ExprBreak

    pub struct ExprBreak { /* fields omitted */ }

    A break, with an optional label to break and an optional +

    Struct syn::ExprBreak[−][src]

    pub struct ExprBreak { /* fields omitted */ }

    A break, with an optional label to break and an optional expression.

    This type is available only if Syn is built with the "full" feature.

    Trait Implementations

    impl From<ExprBreak> for Expr[src]

    impl ToTokens for ExprBreak[src]

    Auto Trait Implementations

    Blanket Implementations

    impl<T> Any for T where
        T: 'static + ?Sized,     [src]

    impl<T> Borrow<T> for T where
        T: ?Sized,     [src]

    impl<T> BorrowMut<T> for T where
        T: ?Sized,     [src]

    impl<T> From<T> for T[src]

    impl<T, U> Into<U> for T where
        U: From<T>,     [src]

    Auto Trait Implementations

    Blanket Implementations

    impl<T> Any for T where
        T: 'static + ?Sized,     [src]

    impl<T> Borrow<T> for T where
        T: ?Sized,     [src]

    impl<T> BorrowMut<T> for T where
        T: ?Sized,     [src]

    impl<T> From<T> for T[src]

    impl<T, U> Into<U> for T where
        U: From<T>,     [src]

    impl<T> Spanned for T where
        T: Spanned + ?Sized,     [src]

    impl<T, U> TryFrom<U> for T where
        U: Into<T>,     [src]

    type Error = Infallible

    The type returned in the event of a conversion error.

    -

    impl<T, U> TryInto<U> for T where
        U: TryFrom<T>,     [src]

    type Error = <U as TryFrom<T>>::Error

    The type returned in the event of a conversion error.

    -
    \ No newline at end of file +

    impl<T, U> TryFrom<U> for T where
        U: Into<T>,     [src]

    type Error = Infallible

    The type returned in the event of a conversion error.

    +

    impl<T, U> TryInto<U> for T where
        U: TryFrom<T>,     [src]

    type Error = <U as TryFrom<T>>::Error

    The type returned in the event of a conversion error.

    +
    + \ No newline at end of file diff --git a/syn/struct.ExprCall.html b/syn/struct.ExprCall.html index 656767c..efd243b 100644 --- a/syn/struct.ExprCall.html +++ b/syn/struct.ExprCall.html @@ -1,7 +1,7 @@ -syn::ExprCall - Rust +syn::ExprCall - Rust -

    [−][src]Struct syn::ExprCall

    pub struct ExprCall {
+
    Struct syn::ExprCall[−][src]
    pub struct ExprCall {
     pub attrs: Vec<Attribute>,
     pub func: Box<Expr>,
     pub paren_token: Paren,
@@ -11,30 +11,31 @@
 "full" feature.
    
 
    
                        Fields
    attrs: Vec<Attribute>func: Box<Expr>paren_token: Parenargs: Punctuated<Expr, Comma>
    Trait Implementations
    impl Clone for ExprCall[src]
    impl Debug for ExprCall[src]
    impl Eq for ExprCall[src]
    impl From<ExprCall> for Expr[src]
    impl Hash for ExprCall[src]
    impl PartialEq<ExprCall> for ExprCall[src]
    impl ToTokens for ExprCall[src]
    Auto Trait Implementations
    Blanket Implementations
    impl<T> Any for T where
        T: 'static + ?Sized,     [src]
    impl<T> Borrow<T> for T where
        T: ?Sized,     [src]
    impl<T> BorrowMut<T> for T where
        T: ?Sized,     [src]
    impl<T> From<T> for T[src]
    impl<T, U> Into<U> for T where
        U: From<T>,     [src]
    impl ToTokens for ExprCall[src]
    Auto Trait Implementations
    impl RefUnwindSafe for ExprCall
    impl !Send for ExprCall
    impl !Sync for ExprCall
    impl Unpin for ExprCall
    impl UnwindSafe for ExprCall
    Blanket Implementations
    impl<T> Any for T where
        T: 'static + ?Sized,     [src]
    impl<T> Borrow<T> for T where
        T: ?Sized,     [src]
    impl<T> BorrowMut<T> for T where
        T: ?Sized,     [src]
    impl<T> From<T> for T[src]
    impl<T, U> Into<U> for T where
        U: From<T>,     [src]
    impl<T> Spanned for T where
        T: Spanned + ?Sized,     [src]
    impl<T> ToOwned for T where
        T: Clone,     [src]
    type Owned = T
    The resulting type after obtaining ownership.
    
-
    impl<T> ToOwned for T where
        T: Clone,     [src]
    type Owned = T
    The resulting type after obtaining ownership.
    
+
    impl<T, U> TryFrom<U> for T where
        U: Into<T>,     [src]
    type Error = Infallible
    The type returned in the event of a conversion error.
    
-
    impl<T, U> TryInto<U> for T where
        U: TryFrom<T>,     [src]
    type Error = <U as TryFrom<T>>::Error
    The type returned in the event of a conversion error.
    
-
    
\ No newline at end of file
+

    impl<T, U> TryFrom<U> for T where
        U: Into<T>,     [src]

    type Error = Infallible

    The type returned in the event of a conversion error.

    +

    impl<T, U> TryInto<U> for T where
        U: TryFrom<T>,     [src]

    type Error = <U as TryFrom<T>>::Error

    The type returned in the event of a conversion error.

    +
    + \ No newline at end of file diff --git a/syn/struct.ExprCast.html b/syn/struct.ExprCast.html index 5099314..6fb7da1 100644 --- a/syn/struct.ExprCast.html +++ b/syn/struct.ExprCast.html @@ -1,7 +1,7 @@ -syn::ExprCast - Rust +syn::ExprCast - Rust -

    [−][src]Struct syn::ExprCast

    pub struct ExprCast {
+
    Struct syn::ExprCast[−][src]
    pub struct ExprCast {
     pub attrs: Vec<Attribute>,
     pub expr: Box<Expr>,
     pub as_token: As,
@@ -11,30 +11,31 @@
 "full" feature.
    
 
    
                        Fields
    attrs: Vec<Attribute>expr: Box<Expr>as_token: Asty: Box<Type>
    Trait Implementations
    impl Clone for ExprCast[src]
    impl Debug for ExprCast[src]
    impl Eq for ExprCast[src]
    impl From<ExprCast> for Expr[src]
    impl Hash for ExprCast[src]
    impl PartialEq<ExprCast> for ExprCast[src]
    impl ToTokens for ExprCast[src]
    Auto Trait Implementations
    Blanket Implementations
    impl<T> Any for T where
        T: 'static + ?Sized,     [src]
    impl<T> Borrow<T> for T where
        T: ?Sized,     [src]
    impl<T> BorrowMut<T> for T where
        T: ?Sized,     [src]
    impl<T> From<T> for T[src]
    impl<T, U> Into<U> for T where
        U: From<T>,     [src]
    impl ToTokens for ExprCast[src]
    Auto Trait Implementations
    impl RefUnwindSafe for ExprCast
    impl !Send for ExprCast
    impl !Sync for ExprCast
    impl Unpin for ExprCast
    impl UnwindSafe for ExprCast
    Blanket Implementations
    impl<T> Any for T where
        T: 'static + ?Sized,     [src]
    impl<T> Borrow<T> for T where
        T: ?Sized,     [src]
    impl<T> BorrowMut<T> for T where
        T: ?Sized,     [src]
    impl<T> From<T> for T[src]
    impl<T, U> Into<U> for T where
        U: From<T>,     [src]
    impl<T> Spanned for T where
        T: Spanned + ?Sized,     [src]
    impl<T> ToOwned for T where
        T: Clone,     [src]
    type Owned = T
    The resulting type after obtaining ownership.
    
-
    impl<T> ToOwned for T where
        T: Clone,     [src]
    type Owned = T
    The resulting type after obtaining ownership.
    
+
    impl<T, U> TryFrom<U> for T where
        U: Into<T>,     [src]
    type Error = Infallible
    The type returned in the event of a conversion error.
    
-
    impl<T, U> TryInto<U> for T where
        U: TryFrom<T>,     [src]
    type Error = <U as TryFrom<T>>::Error
    The type returned in the event of a conversion error.
    
-
    
\ No newline at end of file
+

    impl<T, U> TryFrom<U> for T where
        U: Into<T>,     [src]

    type Error = Infallible

    The type returned in the event of a conversion error.

    +

    impl<T, U> TryInto<U> for T where
        U: TryFrom<T>,     [src]

    type Error = <U as TryFrom<T>>::Error

    The type returned in the event of a conversion error.

    +
    + \ No newline at end of file diff --git a/syn/struct.ExprClosure.html b/syn/struct.ExprClosure.html index 321770d..c9eb105 100644 --- a/syn/struct.ExprClosure.html +++ b/syn/struct.ExprClosure.html @@ -1,21 +1,22 @@ -syn::ExprClosure - Rust +syn::ExprClosure - Rust -

    [−][src]Struct syn::ExprClosure

    pub struct ExprClosure { /* fields omitted */ }

    A closure expression: |a, b| a + b.

    +

    Struct syn::ExprClosure[−][src]

    pub struct ExprClosure { /* fields omitted */ }

    A closure expression: |a, b| a + b.

    This type is available only if Syn is built with the "full" feature.

    Trait Implementations

    impl From<ExprClosure> for Expr[src]

    impl ToTokens for ExprClosure[src]

    Auto Trait Implementations

    Blanket Implementations

    impl<T> Any for T where
        T: 'static + ?Sized,     [src]

    impl<T> Borrow<T> for T where
        T: ?Sized,     [src]

    impl<T> BorrowMut<T> for T where
        T: ?Sized,     [src]

    impl<T> From<T> for T[src]

    impl<T, U> Into<U> for T where
        U: From<T>,     [src]

    Auto Trait Implementations

    Blanket Implementations

    impl<T> Any for T where
        T: 'static + ?Sized,     [src]

    impl<T> Borrow<T> for T where
        T: ?Sized,     [src]

    impl<T> BorrowMut<T> for T where
        T: ?Sized,     [src]

    impl<T> From<T> for T[src]

    impl<T, U> Into<U> for T where
        U: From<T>,     [src]

    impl<T> Spanned for T where
        T: Spanned + ?Sized,     [src]

    impl<T, U> TryFrom<U> for T where
        U: Into<T>,     [src]

    type Error = Infallible

    The type returned in the event of a conversion error.

    -

    impl<T, U> TryInto<U> for T where
        U: TryFrom<T>,     [src]

    type Error = <U as TryFrom<T>>::Error

    The type returned in the event of a conversion error.

    -
    \ No newline at end of file +

    impl<T, U> TryFrom<U> for T where
        U: Into<T>,     [src]

    type Error = Infallible

    The type returned in the event of a conversion error.

    +

    impl<T, U> TryInto<U> for T where
        U: TryFrom<T>,     [src]

    type Error = <U as TryFrom<T>>::Error

    The type returned in the event of a conversion error.

    +
    + \ No newline at end of file diff --git a/syn/struct.ExprContinue.html b/syn/struct.ExprContinue.html index e0c7efd..e5929f9 100644 --- a/syn/struct.ExprContinue.html +++ b/syn/struct.ExprContinue.html @@ -1,21 +1,22 @@ -syn::ExprContinue - Rust +syn::ExprContinue - Rust -

    [−][src]Struct syn::ExprContinue

    pub struct ExprContinue { /* fields omitted */ }

    A continue, with an optional label.

    +

    Struct syn::ExprContinue[−][src]

    pub struct ExprContinue { /* fields omitted */ }

    A continue, with an optional label.

    This type is available only if Syn is built with the "full" feature.

    Trait Implementations

    impl From<ExprContinue> for Expr[src]

    impl ToTokens for ExprContinue[src]

    Auto Trait Implementations

    Blanket Implementations

    impl<T> Any for T where
        T: 'static + ?Sized,     [src]

    impl<T> Borrow<T> for T where
        T: ?Sized,     [src]

    impl<T> BorrowMut<T> for T where
        T: ?Sized,     [src]

    impl<T> From<T> for T[src]

    impl<T, U> Into<U> for T where
        U: From<T>,     [src]

    Auto Trait Implementations

    Blanket Implementations

    impl<T> Any for T where
        T: 'static + ?Sized,     [src]

    impl<T> Borrow<T> for T where
        T: ?Sized,     [src]

    impl<T> BorrowMut<T> for T where
        T: ?Sized,     [src]

    impl<T> From<T> for T[src]

    impl<T, U> Into<U> for T where
        U: From<T>,     [src]

    impl<T> Spanned for T where
        T: Spanned + ?Sized,     [src]

    impl<T, U> TryFrom<U> for T where
        U: Into<T>,     [src]

    type Error = Infallible

    The type returned in the event of a conversion error.

    -

    impl<T, U> TryInto<U> for T where
        U: TryFrom<T>,     [src]

    type Error = <U as TryFrom<T>>::Error

    The type returned in the event of a conversion error.

    -
    \ No newline at end of file +

    impl<T, U> TryFrom<U> for T where
        U: Into<T>,     [src]

    type Error = Infallible

    The type returned in the event of a conversion error.

    +

    impl<T, U> TryInto<U> for T where
        U: TryFrom<T>,     [src]

    type Error = <U as TryFrom<T>>::Error

    The type returned in the event of a conversion error.

    +
    + \ No newline at end of file diff --git a/syn/struct.ExprField.html b/syn/struct.ExprField.html index f7e51b0..b0e4dcf 100644 --- a/syn/struct.ExprField.html +++ b/syn/struct.ExprField.html @@ -1,7 +1,7 @@ -syn::ExprField - Rust +syn::ExprField - Rust -

    [−][src]Struct syn::ExprField

    pub struct ExprField {
+
    Struct syn::ExprField[−][src]
    pub struct ExprField {
     pub attrs: Vec<Attribute>,
     pub base: Box<Expr>,
     pub dot_token: Dot,
@@ -11,30 +11,31 @@ field (obj.0).
    
 
    This type is available only if Syn is built with the "full" feature.
    
 
    
                        Fields
    attrs: Vec<Attribute>base: Box<Expr>dot_token: Dotmember: Member
    Trait Implementations
    impl Clone for ExprField[src]
    impl Debug for ExprField[src]
    impl Eq for ExprField[src]
    impl From<ExprField> for Expr[src]
    impl Hash for ExprField[src]
    impl PartialEq<ExprField> for ExprField[src]
    impl ToTokens for ExprField[src]
    Auto Trait Implementations
    Blanket Implementations
    impl<T> Any for T where
        T: 'static + ?Sized,     [src]
    impl<T> Borrow<T> for T where
        T: ?Sized,     [src]
    impl<T> BorrowMut<T> for T where
        T: ?Sized,     [src]
    impl<T> From<T> for T[src]
    impl<T, U> Into<U> for T where
        U: From<T>,     [src]
    impl ToTokens for ExprField[src]
    Auto Trait Implementations
    Blanket Implementations
    impl<T> Any for T where
        T: 'static + ?Sized,     [src]
    impl<T> Borrow<T> for T where
        T: ?Sized,     [src]
    impl<T> BorrowMut<T> for T where
        T: ?Sized,     [src]
    impl<T> From<T> for T[src]
    impl<T, U> Into<U> for T where
        U: From<T>,     [src]
    impl<T> Spanned for T where
        T: Spanned + ?Sized,     [src]
    impl<T> ToOwned for T where
        T: Clone,     [src]
    type Owned = T
    The resulting type after obtaining ownership.
    
-
    impl<T> ToOwned for T where
        T: Clone,     [src]
    type Owned = T
    The resulting type after obtaining ownership.
    
+
    impl<T, U> TryFrom<U> for T where
        U: Into<T>,     [src]
    type Error = Infallible
    The type returned in the event of a conversion error.
    
-
    impl<T, U> TryInto<U> for T where
        U: TryFrom<T>,     [src]
    type Error = <U as TryFrom<T>>::Error
    The type returned in the event of a conversion error.
    
-
    
\ No newline at end of file
+

    impl<T, U> TryFrom<U> for T where
        U: Into<T>,     [src]

    type Error = Infallible

    The type returned in the event of a conversion error.

    +

    impl<T, U> TryInto<U> for T where
        U: TryFrom<T>,     [src]

    type Error = <U as TryFrom<T>>::Error

    The type returned in the event of a conversion error.

    +
    + \ No newline at end of file diff --git a/syn/struct.ExprForLoop.html b/syn/struct.ExprForLoop.html index c0c4740..970c64e 100644 --- a/syn/struct.ExprForLoop.html +++ b/syn/struct.ExprForLoop.html @@ -1,21 +1,22 @@ -syn::ExprForLoop - Rust +syn::ExprForLoop - Rust -

    [−][src]Struct syn::ExprForLoop

    pub struct ExprForLoop { /* fields omitted */ }

    A for loop: for pat in expr { ... }.

    +

    Struct syn::ExprForLoop[−][src]

    pub struct ExprForLoop { /* fields omitted */ }

    A for loop: for pat in expr { ... }.

    This type is available only if Syn is built with the "full" feature.

    Trait Implementations

    impl From<ExprForLoop> for Expr[src]

    impl ToTokens for ExprForLoop[src]

    Auto Trait Implementations

    Blanket Implementations

    impl<T> Any for T where
        T: 'static + ?Sized,     [src]

    impl<T> Borrow<T> for T where
        T: ?Sized,     [src]

    impl<T> BorrowMut<T> for T where
        T: ?Sized,     [src]

    impl<T> From<T> for T[src]

    impl<T, U> Into<U> for T where
        U: From<T>,     [src]

    Auto Trait Implementations

    Blanket Implementations

    impl<T> Any for T where
        T: 'static + ?Sized,     [src]

    impl<T> Borrow<T> for T where
        T: ?Sized,     [src]

    impl<T> BorrowMut<T> for T where
        T: ?Sized,     [src]

    impl<T> From<T> for T[src]

    impl<T, U> Into<U> for T where
        U: From<T>,     [src]

    impl<T> Spanned for T where
        T: Spanned + ?Sized,     [src]

    impl<T, U> TryFrom<U> for T where
        U: Into<T>,     [src]

    type Error = Infallible

    The type returned in the event of a conversion error.

    -

    impl<T, U> TryInto<U> for T where
        U: TryFrom<T>,     [src]

    type Error = <U as TryFrom<T>>::Error

    The type returned in the event of a conversion error.

    -
    \ No newline at end of file +

    impl<T, U> TryFrom<U> for T where
        U: Into<T>,     [src]

    type Error = Infallible

    The type returned in the event of a conversion error.

    +

    impl<T, U> TryInto<U> for T where
        U: TryFrom<T>,     [src]

    type Error = <U as TryFrom<T>>::Error

    The type returned in the event of a conversion error.

    +
    + \ No newline at end of file diff --git a/syn/struct.ExprGroup.html b/syn/struct.ExprGroup.html index 523da08..5e71aee 100644 --- a/syn/struct.ExprGroup.html +++ b/syn/struct.ExprGroup.html @@ -1,24 +1,25 @@ -syn::ExprGroup - Rust +syn::ExprGroup - Rust -

    [−][src]Struct syn::ExprGroup

    pub struct ExprGroup { /* fields omitted */ }

    An expression contained within invisible delimiters.

    +

    Struct syn::ExprGroup[−][src]

    pub struct ExprGroup { /* fields omitted */ }

    An expression contained within invisible delimiters.

    This variant is important for faithfully representing the precedence of expressions and is related to None-delimited spans in a TokenStream.

    This type is available only if Syn is built with the "full" feature.

    Trait Implementations

    impl From<ExprGroup> for Expr[src]

    impl ToTokens for ExprGroup[src]

    Auto Trait Implementations

    Blanket Implementations

    impl<T> Any for T where
        T: 'static + ?Sized,     [src]

    impl<T> Borrow<T> for T where
        T: ?Sized,     [src]

    impl<T> BorrowMut<T> for T where
        T: ?Sized,     [src]

    impl<T> From<T> for T[src]

    impl<T, U> Into<U> for T where
        U: From<T>,     [src]

    Auto Trait Implementations

    Blanket Implementations

    impl<T> Any for T where
        T: 'static + ?Sized,     [src]

    impl<T> Borrow<T> for T where
        T: ?Sized,     [src]

    impl<T> BorrowMut<T> for T where
        T: ?Sized,     [src]

    impl<T> From<T> for T[src]

    impl<T, U> Into<U> for T where
        U: From<T>,     [src]

    impl<T> Spanned for T where
        T: Spanned + ?Sized,     [src]

    impl<T, U> TryFrom<U> for T where
        U: Into<T>,     [src]

    type Error = Infallible

    The type returned in the event of a conversion error.

    -

    impl<T, U> TryInto<U> for T where
        U: TryFrom<T>,     [src]

    type Error = <U as TryFrom<T>>::Error

    The type returned in the event of a conversion error.

    -
    \ No newline at end of file +

    impl<T, U> TryFrom<U> for T where
        U: Into<T>,     [src]

    type Error = Infallible

    The type returned in the event of a conversion error.

    +

    impl<T, U> TryInto<U> for T where
        U: TryFrom<T>,     [src]

    type Error = <U as TryFrom<T>>::Error

    The type returned in the event of a conversion error.

    +
    + \ No newline at end of file diff --git a/syn/struct.ExprIf.html b/syn/struct.ExprIf.html index 3eba353..24f5d7a 100644 --- a/syn/struct.ExprIf.html +++ b/syn/struct.ExprIf.html @@ -1,23 +1,24 @@ -syn::ExprIf - Rust +syn::ExprIf - Rust -

    [−][src]Struct syn::ExprIf

    pub struct ExprIf { /* fields omitted */ }

    An if expression with an optional else block: if expr { ... } else { ... }.

    +

    Struct syn::ExprIf[−][src]

    pub struct ExprIf { /* fields omitted */ }

    An if expression with an optional else block: if expr { ... } else { ... }.

    The else branch expression may only be an If or Block expression, not any of the other types of expression.

    This type is available only if Syn is built with the "full" feature.

    Trait Implementations

    impl From<ExprIf> for Expr[src]

    impl ToTokens for ExprIf[src]

    Auto Trait Implementations

    Blanket Implementations

    impl<T> Any for T where
        T: 'static + ?Sized,     [src]

    impl<T> Borrow<T> for T where
        T: ?Sized,     [src]

    impl<T> BorrowMut<T> for T where
        T: ?Sized,     [src]

    impl<T> From<T> for T[src]

    impl<T, U> Into<U> for T where
        U: From<T>,     [src]

    Auto Trait Implementations

    impl RefUnwindSafe for ExprIf

    impl !Send for ExprIf

    impl !Sync for ExprIf

    impl Unpin for ExprIf

    impl UnwindSafe for ExprIf

    Blanket Implementations

    impl<T> Any for T where
        T: 'static + ?Sized,     [src]

    impl<T> Borrow<T> for T where
        T: ?Sized,     [src]

    impl<T> BorrowMut<T> for T where
        T: ?Sized,     [src]

    impl<T> From<T> for T[src]

    impl<T, U> Into<U> for T where
        U: From<T>,     [src]

    impl<T> Spanned for T where
        T: Spanned + ?Sized,     [src]

    impl<T, U> TryFrom<U> for T where
        U: Into<T>,     [src]

    type Error = Infallible

    The type returned in the event of a conversion error.

    -

    impl<T, U> TryInto<U> for T where
        U: TryFrom<T>,     [src]

    type Error = <U as TryFrom<T>>::Error

    The type returned in the event of a conversion error.

    -
    \ No newline at end of file +

    impl<T, U> TryFrom<U> for T where
        U: Into<T>,     [src]

    type Error = Infallible

    The type returned in the event of a conversion error.

    +

    impl<T, U> TryInto<U> for T where
        U: TryFrom<T>,     [src]

    type Error = <U as TryFrom<T>>::Error

    The type returned in the event of a conversion error.

    +
    + \ No newline at end of file diff --git a/syn/struct.ExprIndex.html b/syn/struct.ExprIndex.html index 9fb391b..05b149f 100644 --- a/syn/struct.ExprIndex.html +++ b/syn/struct.ExprIndex.html @@ -1,7 +1,7 @@ -syn::ExprIndex - Rust +syn::ExprIndex - Rust -

    [−][src]Struct syn::ExprIndex

    pub struct ExprIndex {
+
    Struct syn::ExprIndex[−][src]
    pub struct ExprIndex {
     pub attrs: Vec<Attribute>,
     pub expr: Box<Expr>,
     pub bracket_token: Bracket,
@@ -11,30 +11,31 @@
 "full" feature.
    
 
    
                        Fields
    attrs: Vec<Attribute>expr: Box<Expr>bracket_token: Bracketindex: Box<Expr>
    Trait Implementations
    impl Clone for ExprIndex[src]
    impl Debug for ExprIndex[src]
    impl Eq for ExprIndex[src]
    impl From<ExprIndex> for Expr[src]
    impl Hash for ExprIndex[src]
    impl PartialEq<ExprIndex> for ExprIndex[src]
    impl ToTokens for ExprIndex[src]
    Auto Trait Implementations
    Blanket Implementations
    impl<T> Any for T where
        T: 'static + ?Sized,     [src]
    impl<T> Borrow<T> for T where
        T: ?Sized,     [src]
    impl<T> BorrowMut<T> for T where
        T: ?Sized,     [src]
    impl<T> From<T> for T[src]
    impl<T, U> Into<U> for T where
        U: From<T>,     [src]
    impl ToTokens for ExprIndex[src]
    Auto Trait Implementations
    Blanket Implementations
    impl<T> Any for T where
        T: 'static + ?Sized,     [src]
    impl<T> Borrow<T> for T where
        T: ?Sized,     [src]
    impl<T> BorrowMut<T> for T where
        T: ?Sized,     [src]
    impl<T> From<T> for T[src]
    impl<T, U> Into<U> for T where
        U: From<T>,     [src]
    impl<T> Spanned for T where
        T: Spanned + ?Sized,     [src]
    impl<T> ToOwned for T where
        T: Clone,     [src]
    type Owned = T
    The resulting type after obtaining ownership.
    
-
    impl<T> ToOwned for T where
        T: Clone,     [src]
    type Owned = T
    The resulting type after obtaining ownership.
    
+
    impl<T, U> TryFrom<U> for T where
        U: Into<T>,     [src]
    type Error = Infallible
    The type returned in the event of a conversion error.
    
-
    impl<T, U> TryInto<U> for T where
        U: TryFrom<T>,     [src]
    type Error = <U as TryFrom<T>>::Error
    The type returned in the event of a conversion error.
    
-
    
\ No newline at end of file
+

    impl<T, U> TryFrom<U> for T where
        U: Into<T>,     [src]

    type Error = Infallible

    The type returned in the event of a conversion error.

    +

    impl<T, U> TryInto<U> for T where
        U: TryFrom<T>,     [src]

    type Error = <U as TryFrom<T>>::Error

    The type returned in the event of a conversion error.

    +
    + \ No newline at end of file diff --git a/syn/struct.ExprLet.html b/syn/struct.ExprLet.html index bbb8c38..d024298 100644 --- a/syn/struct.ExprLet.html +++ b/syn/struct.ExprLet.html @@ -1,21 +1,22 @@ -syn::ExprLet - Rust +syn::ExprLet - Rust -

    [−][src]Struct syn::ExprLet

    pub struct ExprLet { /* fields omitted */ }

    A let guard: let Some(x) = opt.

    +

    Struct syn::ExprLet[−][src]

    pub struct ExprLet { /* fields omitted */ }

    A let guard: let Some(x) = opt.

    This type is available only if Syn is built with the "full" feature.

    Trait Implementations

    impl From<ExprLet> for Expr[src]

    impl ToTokens for ExprLet[src]

    Auto Trait Implementations

    Blanket Implementations

    impl<T> Any for T where
        T: 'static + ?Sized,     [src]

    impl<T> Borrow<T> for T where
        T: ?Sized,     [src]

    impl<T> BorrowMut<T> for T where
        T: ?Sized,     [src]

    impl<T> From<T> for T[src]

    impl<T, U> Into<U> for T where
        U: From<T>,     [src]

    Auto Trait Implementations

    impl RefUnwindSafe for ExprLet

    impl !Send for ExprLet

    impl !Sync for ExprLet

    impl Unpin for ExprLet

    impl UnwindSafe for ExprLet

    Blanket Implementations

    impl<T> Any for T where
        T: 'static + ?Sized,     [src]

    impl<T> Borrow<T> for T where
        T: ?Sized,     [src]

    impl<T> BorrowMut<T> for T where
        T: ?Sized,     [src]

    impl<T> From<T> for T[src]

    impl<T, U> Into<U> for T where
        U: From<T>,     [src]

    impl<T> Spanned for T where
        T: Spanned + ?Sized,     [src]

    impl<T, U> TryFrom<U> for T where
        U: Into<T>,     [src]

    type Error = Infallible

    The type returned in the event of a conversion error.

    -

    impl<T, U> TryInto<U> for T where
        U: TryFrom<T>,     [src]

    type Error = <U as TryFrom<T>>::Error

    The type returned in the event of a conversion error.

    -
    \ No newline at end of file +

    impl<T, U> TryFrom<U> for T where
        U: Into<T>,     [src]

    type Error = Infallible

    The type returned in the event of a conversion error.

    +

    impl<T, U> TryInto<U> for T where
        U: TryFrom<T>,     [src]

    type Error = <U as TryFrom<T>>::Error

    The type returned in the event of a conversion error.

    +
    + \ No newline at end of file diff --git a/syn/struct.ExprLit.html b/syn/struct.ExprLit.html index f29dac9..1c79ddd 100644 --- a/syn/struct.ExprLit.html +++ b/syn/struct.ExprLit.html @@ -1,7 +1,7 @@ -syn::ExprLit - Rust +syn::ExprLit - Rust -

    [−][src]Struct syn::ExprLit

    pub struct ExprLit {
+
    Struct syn::ExprLit[−][src]
    pub struct ExprLit {
     pub attrs: Vec<Attribute>,
     pub lit: Lit,
 }
    A literal in place of an expression: 1, "foo".
    
@@ -9,30 +9,31 @@
 "full" feature.
    
 
    
                        Fields
    attrs: Vec<Attribute>lit: Lit
    Trait Implementations
    impl Clone for ExprLit[src]
    impl Debug for ExprLit[src]
    impl Eq for ExprLit[src]
    impl From<ExprLit> for Expr[src]
    impl Hash for ExprLit[src]
    impl Parse for ExprLit[src]
    impl PartialEq<ExprLit> for ExprLit[src]
    impl Parse for ExprLit[src]
    impl PartialEq<ExprLit> for ExprLit[src]
    impl ToTokens for ExprLit[src]
    Auto Trait Implementations
    Blanket Implementations
    impl<T> Any for T where
        T: 'static + ?Sized,     [src]
    impl<T> Borrow<T> for T where
        T: ?Sized,     [src]
    impl<T> BorrowMut<T> for T where
        T: ?Sized,     [src]
    impl<T> From<T> for T[src]
    impl<T, U> Into<U> for T where
        U: From<T>,     [src]
    impl ToTokens for ExprLit[src]
    Auto Trait Implementations
    impl RefUnwindSafe for ExprLit
    impl !Send for ExprLit
    impl !Sync for ExprLit
    impl Unpin for ExprLit
    impl UnwindSafe for ExprLit
    Blanket Implementations
    impl<T> Any for T where
        T: 'static + ?Sized,     [src]
    impl<T> Borrow<T> for T where
        T: ?Sized,     [src]
    impl<T> BorrowMut<T> for T where
        T: ?Sized,     [src]
    impl<T> From<T> for T[src]
    impl<T, U> Into<U> for T where
        U: From<T>,     [src]
    impl<T> Spanned for T where
        T: Spanned + ?Sized,     [src]
    impl<T> ToOwned for T where
        T: Clone,     [src]
    type Owned = T
    The resulting type after obtaining ownership.
    
-
    impl<T> ToOwned for T where
        T: Clone,     [src]
    type Owned = T
    The resulting type after obtaining ownership.
    
+
    impl<T, U> TryFrom<U> for T where
        U: Into<T>,     [src]
    type Error = Infallible
    The type returned in the event of a conversion error.
    
-
    impl<T, U> TryInto<U> for T where
        U: TryFrom<T>,     [src]
    type Error = <U as TryFrom<T>>::Error
    The type returned in the event of a conversion error.
    
-
    
\ No newline at end of file
+

    impl<T, U> TryFrom<U> for T where
        U: Into<T>,     [src]

    type Error = Infallible

    The type returned in the event of a conversion error.

    +

    impl<T, U> TryInto<U> for T where
        U: TryFrom<T>,     [src]

    type Error = <U as TryFrom<T>>::Error

    The type returned in the event of a conversion error.

    +
    + \ No newline at end of file diff --git a/syn/struct.ExprLoop.html b/syn/struct.ExprLoop.html index a702993..8bc26ff 100644 --- a/syn/struct.ExprLoop.html +++ b/syn/struct.ExprLoop.html @@ -1,21 +1,22 @@ -syn::ExprLoop - Rust +syn::ExprLoop - Rust -

    [−][src]Struct syn::ExprLoop

    pub struct ExprLoop { /* fields omitted */ }

    Conditionless loop: loop { ... }.

    +

    Struct syn::ExprLoop[−][src]

    pub struct ExprLoop { /* fields omitted */ }

    Conditionless loop: loop { ... }.

    This type is available only if Syn is built with the "full" feature.

    Trait Implementations

    impl From<ExprLoop> for Expr[src]

    impl ToTokens for ExprLoop[src]

    Auto Trait Implementations

    Blanket Implementations

    impl<T> Any for T where
        T: 'static + ?Sized,     [src]

    impl<T> Borrow<T> for T where
        T: ?Sized,     [src]

    impl<T> BorrowMut<T> for T where
        T: ?Sized,     [src]

    impl<T> From<T> for T[src]

    impl<T, U> Into<U> for T where
        U: From<T>,     [src]

    Auto Trait Implementations

    impl RefUnwindSafe for ExprLoop

    impl !Send for ExprLoop

    impl !Sync for ExprLoop

    impl Unpin for ExprLoop

    impl UnwindSafe for ExprLoop

    Blanket Implementations

    impl<T> Any for T where
        T: 'static + ?Sized,     [src]

    impl<T> Borrow<T> for T where
        T: ?Sized,     [src]

    impl<T> BorrowMut<T> for T where
        T: ?Sized,     [src]

    impl<T> From<T> for T[src]

    impl<T, U> Into<U> for T where
        U: From<T>,     [src]

    impl<T> Spanned for T where
        T: Spanned + ?Sized,     [src]

    impl<T, U> TryFrom<U> for T where
        U: Into<T>,     [src]

    type Error = Infallible

    The type returned in the event of a conversion error.

    -

    impl<T, U> TryInto<U> for T where
        U: TryFrom<T>,     [src]

    type Error = <U as TryFrom<T>>::Error

    The type returned in the event of a conversion error.

    -
    \ No newline at end of file +

    impl<T, U> TryFrom<U> for T where
        U: Into<T>,     [src]

    type Error = Infallible

    The type returned in the event of a conversion error.

    +

    impl<T, U> TryInto<U> for T where
        U: TryFrom<T>,     [src]

    type Error = <U as TryFrom<T>>::Error

    The type returned in the event of a conversion error.

    +
    + \ No newline at end of file diff --git a/syn/struct.ExprMacro.html b/syn/struct.ExprMacro.html index 91e4c13..363075a 100644 --- a/syn/struct.ExprMacro.html +++ b/syn/struct.ExprMacro.html @@ -1,21 +1,22 @@ -syn::ExprMacro - Rust +syn::ExprMacro - Rust -

    [−][src]Struct syn::ExprMacro

    pub struct ExprMacro { /* fields omitted */ }

    A macro invocation expression: format!("{}", q).

    +

    Struct syn::ExprMacro[−][src]

    pub struct ExprMacro { /* fields omitted */ }

    A macro invocation expression: format!("{}", q).

    This type is available only if Syn is built with the "full" feature.

    Trait Implementations

    impl From<ExprMacro> for Expr[src]

    impl ToTokens for ExprMacro[src]

    Auto Trait Implementations

    Blanket Implementations

    impl<T> Any for T where
        T: 'static + ?Sized,     [src]

    impl<T> Borrow<T> for T where
        T: ?Sized,     [src]

    impl<T> BorrowMut<T> for T where
        T: ?Sized,     [src]

    impl<T> From<T> for T[src]

    impl<T, U> Into<U> for T where
        U: From<T>,     [src]

    Auto Trait Implementations

    Blanket Implementations

    impl<T> Any for T where
        T: 'static + ?Sized,     [src]

    impl<T> Borrow<T> for T where
        T: ?Sized,     [src]

    impl<T> BorrowMut<T> for T where
        T: ?Sized,     [src]

    impl<T> From<T> for T[src]

    impl<T, U> Into<U> for T where
        U: From<T>,     [src]

    impl<T> Spanned for T where
        T: Spanned + ?Sized,     [src]

    impl<T, U> TryFrom<U> for T where
        U: Into<T>,     [src]

    type Error = Infallible

    The type returned in the event of a conversion error.

    -

    impl<T, U> TryInto<U> for T where
        U: TryFrom<T>,     [src]

    type Error = <U as TryFrom<T>>::Error

    The type returned in the event of a conversion error.

    -
    \ No newline at end of file +

    impl<T, U> TryFrom<U> for T where
        U: Into<T>,     [src]

    type Error = Infallible

    The type returned in the event of a conversion error.

    +

    impl<T, U> TryInto<U> for T where
        U: TryFrom<T>,     [src]

    type Error = <U as TryFrom<T>>::Error

    The type returned in the event of a conversion error.

    +
    + \ No newline at end of file diff --git a/syn/struct.ExprMatch.html b/syn/struct.ExprMatch.html index 98ba89c..e129876 100644 --- a/syn/struct.ExprMatch.html +++ b/syn/struct.ExprMatch.html @@ -1,21 +1,22 @@ -syn::ExprMatch - Rust +syn::ExprMatch - Rust -

    [−][src]Struct syn::ExprMatch

    pub struct ExprMatch { /* fields omitted */ }

    A match expression: match n { Some(n) => {}, None => {} }.

    +

    Struct syn::ExprMatch[−][src]

    pub struct ExprMatch { /* fields omitted */ }

    A match expression: match n { Some(n) => {}, None => {} }.

    This type is available only if Syn is built with the "full" feature.

    Trait Implementations

    impl From<ExprMatch> for Expr[src]

    impl ToTokens for ExprMatch[src]

    Auto Trait Implementations

    Blanket Implementations

    impl<T> Any for T where
        T: 'static + ?Sized,     [src]

    impl<T> Borrow<T> for T where
        T: ?Sized,     [src]

    impl<T> BorrowMut<T> for T where
        T: ?Sized,     [src]

    impl<T> From<T> for T[src]

    impl<T, U> Into<U> for T where
        U: From<T>,     [src]

    Auto Trait Implementations

    Blanket Implementations

    impl<T> Any for T where
        T: 'static + ?Sized,     [src]

    impl<T> Borrow<T> for T where
        T: ?Sized,     [src]

    impl<T> BorrowMut<T> for T where
        T: ?Sized,     [src]

    impl<T> From<T> for T[src]

    impl<T, U> Into<U> for T where
        U: From<T>,     [src]

    impl<T> Spanned for T where
        T: Spanned + ?Sized,     [src]

    impl<T, U> TryFrom<U> for T where
        U: Into<T>,     [src]

    type Error = Infallible

    The type returned in the event of a conversion error.

    -

    impl<T, U> TryInto<U> for T where
        U: TryFrom<T>,     [src]

    type Error = <U as TryFrom<T>>::Error

    The type returned in the event of a conversion error.

    -
    \ No newline at end of file +

    impl<T, U> TryFrom<U> for T where
        U: Into<T>,     [src]

    type Error = Infallible

    The type returned in the event of a conversion error.

    +

    impl<T, U> TryInto<U> for T where
        U: TryFrom<T>,     [src]

    type Error = <U as TryFrom<T>>::Error

    The type returned in the event of a conversion error.

    +
    + \ No newline at end of file diff --git a/syn/struct.ExprMethodCall.html b/syn/struct.ExprMethodCall.html index ae4aca7..608f1dc 100644 --- a/syn/struct.ExprMethodCall.html +++ b/syn/struct.ExprMethodCall.html @@ -1,21 +1,22 @@ -syn::ExprMethodCall - Rust +syn::ExprMethodCall - Rust -

    [−][src]Struct syn::ExprMethodCall

    pub struct ExprMethodCall { /* fields omitted */ }

    A method call expression: x.foo::<T>(a, b).

    +

    Struct syn::ExprMethodCall[−][src]

    pub struct ExprMethodCall { /* fields omitted */ }

    A method call expression: x.foo::<T>(a, b).

    This type is available only if Syn is built with the "full" feature.

    Trait Implementations

    impl From<ExprMethodCall> for Expr[src]

    impl ToTokens for ExprMethodCall[src]

    Auto Trait Implementations

    Blanket Implementations

    impl<T> Any for T where
        T: 'static + ?Sized,     [src]

    impl<T> Borrow<T> for T where
        T: ?Sized,     [src]

    impl<T> BorrowMut<T> for T where
        T: ?Sized,     [src]

    impl<T> From<T> for T[src]

    impl<T, U> Into<U> for T where
        U: From<T>,     [src]

    Auto Trait Implementations

    Blanket Implementations

    impl<T> Any for T where
        T: 'static + ?Sized,     [src]

    impl<T> Borrow<T> for T where
        T: ?Sized,     [src]

    impl<T> BorrowMut<T> for T where
        T: ?Sized,     [src]

    impl<T> From<T> for T[src]

    impl<T, U> Into<U> for T where
        U: From<T>,     [src]

    impl<T> Spanned for T where
        T: Spanned + ?Sized,     [src]

    impl<T, U> TryFrom<U> for T where
        U: Into<T>,     [src]

    type Error = Infallible

    The type returned in the event of a conversion error.

    -

    impl<T, U> TryInto<U> for T where
        U: TryFrom<T>,     [src]

    type Error = <U as TryFrom<T>>::Error

    The type returned in the event of a conversion error.

    -
    \ No newline at end of file +

    impl<T, U> TryFrom<U> for T where
        U: Into<T>,     [src]

    type Error = Infallible

    The type returned in the event of a conversion error.

    +

    impl<T, U> TryInto<U> for T where
        U: TryFrom<T>,     [src]

    type Error = <U as TryFrom<T>>::Error

    The type returned in the event of a conversion error.

    +
    + \ No newline at end of file diff --git a/syn/struct.ExprParen.html b/syn/struct.ExprParen.html index 3f0920f..0eb4f88 100644 --- a/syn/struct.ExprParen.html +++ b/syn/struct.ExprParen.html @@ -1,7 +1,7 @@ -syn::ExprParen - Rust +syn::ExprParen - Rust -

    [−][src]Struct syn::ExprParen

    pub struct ExprParen {
+
    Struct syn::ExprParen[−][src]
    pub struct ExprParen {
     pub attrs: Vec<Attribute>,
     pub paren_token: Paren,
     pub expr: Box<Expr>,
@@ -9,30 +9,31 @@
 
    This type is available only if Syn is built with the "full" feature.
    
 
    
                        Fields
    attrs: Vec<Attribute>paren_token: Parenexpr: Box<Expr>
    Trait Implementations
    impl Clone for ExprParen[src]
    impl Debug for ExprParen[src]
    impl Eq for ExprParen[src]
    impl From<ExprParen> for Expr[src]
    impl Hash for ExprParen[src]
    impl PartialEq<ExprParen> for ExprParen[src]
    impl ToTokens for ExprParen[src]
    Auto Trait Implementations
    Blanket Implementations
    impl<T> Any for T where
        T: 'static + ?Sized,     [src]
    impl<T> Borrow<T> for T where
        T: ?Sized,     [src]
    impl<T> BorrowMut<T> for T where
        T: ?Sized,     [src]
    impl<T> From<T> for T[src]
    impl<T, U> Into<U> for T where
        U: From<T>,     [src]
    impl ToTokens for ExprParen[src]
    Auto Trait Implementations
    Blanket Implementations
    impl<T> Any for T where
        T: 'static + ?Sized,     [src]
    impl<T> Borrow<T> for T where
        T: ?Sized,     [src]
    impl<T> BorrowMut<T> for T where
        T: ?Sized,     [src]
    impl<T> From<T> for T[src]
    impl<T, U> Into<U> for T where
        U: From<T>,     [src]
    impl<T> Spanned for T where
        T: Spanned + ?Sized,     [src]
    impl<T> ToOwned for T where
        T: Clone,     [src]
    type Owned = T
    The resulting type after obtaining ownership.
    
-
    impl<T> ToOwned for T where
        T: Clone,     [src]
    type Owned = T
    The resulting type after obtaining ownership.
    
+
    impl<T, U> TryFrom<U> for T where
        U: Into<T>,     [src]
    type Error = Infallible
    The type returned in the event of a conversion error.
    
-
    impl<T, U> TryInto<U> for T where
        U: TryFrom<T>,     [src]
    type Error = <U as TryFrom<T>>::Error
    The type returned in the event of a conversion error.
    
-
    
\ No newline at end of file
+

    impl<T, U> TryFrom<U> for T where
        U: Into<T>,     [src]

    type Error = Infallible

    The type returned in the event of a conversion error.

    +

    impl<T, U> TryInto<U> for T where
        U: TryFrom<T>,     [src]

    type Error = <U as TryFrom<T>>::Error

    The type returned in the event of a conversion error.

    +
    + \ No newline at end of file diff --git a/syn/struct.ExprPath.html b/syn/struct.ExprPath.html index d820e7b..02a64ce 100644 --- a/syn/struct.ExprPath.html +++ b/syn/struct.ExprPath.html @@ -1,7 +1,7 @@ -syn::ExprPath - Rust +syn::ExprPath - Rust -

    [−][src]Struct syn::ExprPath

    pub struct ExprPath {
+
    Struct syn::ExprPath[−][src]
    pub struct ExprPath {
     pub attrs: Vec<Attribute>,
     pub qself: Option<QSelf>,
     pub path: Path,
@@ -12,30 +12,31 @@ parameters and a qualified self-type.
    
 "full" feature.
    
 
    
                        Fields
    attrs: Vec<Attribute>qself: Option<QSelf>path: Path
    Trait Implementations
    impl Clone for ExprPath[src]
    impl Debug for ExprPath[src]
    impl Eq for ExprPath[src]
    impl From<ExprPath> for Expr[src]
    impl Hash for ExprPath[src]
    impl Parse for ExprPath[src]
    impl PartialEq<ExprPath> for ExprPath[src]
    impl Parse for ExprPath[src]
    impl PartialEq<ExprPath> for ExprPath[src]
    impl ToTokens for ExprPath[src]
    Auto Trait Implementations
    Blanket Implementations
    impl<T> Any for T where
        T: 'static + ?Sized,     [src]
    impl<T> Borrow<T> for T where
        T: ?Sized,     [src]
    impl<T> BorrowMut<T> for T where
        T: ?Sized,     [src]
    impl<T> From<T> for T[src]
    impl<T, U> Into<U> for T where
        U: From<T>,     [src]
    impl ToTokens for ExprPath[src]
    Auto Trait Implementations
    impl RefUnwindSafe for ExprPath
    impl !Send for ExprPath
    impl !Sync for ExprPath
    impl Unpin for ExprPath
    impl UnwindSafe for ExprPath
    Blanket Implementations
    impl<T> Any for T where
        T: 'static + ?Sized,     [src]
    impl<T> Borrow<T> for T where
        T: ?Sized,     [src]
    impl<T> BorrowMut<T> for T where
        T: ?Sized,     [src]
    impl<T> From<T> for T[src]
    impl<T, U> Into<U> for T where
        U: From<T>,     [src]
    impl<T> Spanned for T where
        T: Spanned + ?Sized,     [src]
    impl<T> ToOwned for T where
        T: Clone,     [src]
    type Owned = T
    The resulting type after obtaining ownership.
    
-
    impl<T> ToOwned for T where
        T: Clone,     [src]
    type Owned = T
    The resulting type after obtaining ownership.
    
+
    impl<T, U> TryFrom<U> for T where
        U: Into<T>,     [src]
    type Error = Infallible
    The type returned in the event of a conversion error.
    
-
    impl<T, U> TryInto<U> for T where
        U: TryFrom<T>,     [src]
    type Error = <U as TryFrom<T>>::Error
    The type returned in the event of a conversion error.
    
-
    
\ No newline at end of file
+

    impl<T, U> TryFrom<U> for T where
        U: Into<T>,     [src]

    type Error = Infallible

    The type returned in the event of a conversion error.

    +

    impl<T, U> TryInto<U> for T where
        U: TryFrom<T>,     [src]

    type Error = <U as TryFrom<T>>::Error

    The type returned in the event of a conversion error.

    +
    + \ No newline at end of file diff --git a/syn/struct.ExprRange.html b/syn/struct.ExprRange.html index 81574b5..7659c50 100644 --- a/syn/struct.ExprRange.html +++ b/syn/struct.ExprRange.html @@ -1,21 +1,22 @@ -syn::ExprRange - Rust +syn::ExprRange - Rust -

    [−][src]Struct syn::ExprRange

    pub struct ExprRange { /* fields omitted */ }

    A range expression: 1..2, 1.., ..2, 1..=2, ..=2.

    +

    Struct syn::ExprRange[−][src]

    pub struct ExprRange { /* fields omitted */ }

    A range expression: 1..2, 1.., ..2, 1..=2, ..=2.

    This type is available only if Syn is built with the "full" feature.

    Trait Implementations

    impl From<ExprRange> for Expr[src]

    impl ToTokens for ExprRange[src]

    Auto Trait Implementations

    Blanket Implementations

    impl<T> Any for T where
        T: 'static + ?Sized,     [src]

    impl<T> Borrow<T> for T where
        T: ?Sized,     [src]

    impl<T> BorrowMut<T> for T where
        T: ?Sized,     [src]

    impl<T> From<T> for T[src]

    impl<T, U> Into<U> for T where
        U: From<T>,     [src]

    Auto Trait Implementations

    Blanket Implementations

    impl<T> Any for T where
        T: 'static + ?Sized,     [src]

    impl<T> Borrow<T> for T where
        T: ?Sized,     [src]

    impl<T> BorrowMut<T> for T where
        T: ?Sized,     [src]

    impl<T> From<T> for T[src]

    impl<T, U> Into<U> for T where
        U: From<T>,     [src]

    impl<T> Spanned for T where
        T: Spanned + ?Sized,     [src]

    impl<T, U> TryFrom<U> for T where
        U: Into<T>,     [src]

    type Error = Infallible

    The type returned in the event of a conversion error.

    -

    impl<T, U> TryInto<U> for T where
        U: TryFrom<T>,     [src]

    type Error = <U as TryFrom<T>>::Error

    The type returned in the event of a conversion error.

    -
    \ No newline at end of file +

    impl<T, U> TryFrom<U> for T where
        U: Into<T>,     [src]

    type Error = Infallible

    The type returned in the event of a conversion error.

    +

    impl<T, U> TryInto<U> for T where
        U: TryFrom<T>,     [src]

    type Error = <U as TryFrom<T>>::Error

    The type returned in the event of a conversion error.

    +
    + \ No newline at end of file diff --git a/syn/struct.ExprReference.html b/syn/struct.ExprReference.html index 3d6c358..620fb45 100644 --- a/syn/struct.ExprReference.html +++ b/syn/struct.ExprReference.html @@ -1,21 +1,22 @@ -syn::ExprReference - Rust +syn::ExprReference - Rust -

    [−][src]Struct syn::ExprReference

    pub struct ExprReference { /* fields omitted */ }

    A referencing operation: &a or &mut a.

    +

    Struct syn::ExprReference[−][src]

    pub struct ExprReference { /* fields omitted */ }

    A referencing operation: &a or &mut a.

    This type is available only if Syn is built with the "full" feature.

    Trait Implementations

    impl From<ExprReference> for Expr[src]

    impl ToTokens for ExprReference[src]

    Auto Trait Implementations

    Blanket Implementations

    impl<T> Any for T where
        T: 'static + ?Sized,     [src]

    impl<T> Borrow<T> for T where
        T: ?Sized,     [src]

    impl<T> BorrowMut<T> for T where
        T: ?Sized,     [src]

    impl<T> From<T> for T[src]

    impl<T, U> Into<U> for T where
        U: From<T>,     [src]

    Auto Trait Implementations

    Blanket Implementations

    impl<T> Any for T where
        T: 'static + ?Sized,     [src]

    impl<T> Borrow<T> for T where
        T: ?Sized,     [src]

    impl<T> BorrowMut<T> for T where
        T: ?Sized,     [src]

    impl<T> From<T> for T[src]

    impl<T, U> Into<U> for T where
        U: From<T>,     [src]

    impl<T> Spanned for T where
        T: Spanned + ?Sized,     [src]

    impl<T, U> TryFrom<U> for T where
        U: Into<T>,     [src]

    type Error = Infallible

    The type returned in the event of a conversion error.

    -

    impl<T, U> TryInto<U> for T where
        U: TryFrom<T>,     [src]

    type Error = <U as TryFrom<T>>::Error

    The type returned in the event of a conversion error.

    -
    \ No newline at end of file +

    impl<T, U> TryFrom<U> for T where
        U: Into<T>,     [src]

    type Error = Infallible

    The type returned in the event of a conversion error.

    +

    impl<T, U> TryInto<U> for T where
        U: TryFrom<T>,     [src]

    type Error = <U as TryFrom<T>>::Error

    The type returned in the event of a conversion error.

    +
    + \ No newline at end of file diff --git a/syn/struct.ExprRepeat.html b/syn/struct.ExprRepeat.html index 9fe8b8a..d11552d 100644 --- a/syn/struct.ExprRepeat.html +++ b/syn/struct.ExprRepeat.html @@ -1,21 +1,22 @@ -syn::ExprRepeat - Rust +syn::ExprRepeat - Rust -

    [−][src]Struct syn::ExprRepeat

    pub struct ExprRepeat { /* fields omitted */ }

    An array literal constructed from one repeated element: [0u8; N].

    +

    Struct syn::ExprRepeat[−][src]

    pub struct ExprRepeat { /* fields omitted */ }

    An array literal constructed from one repeated element: [0u8; N].

    This type is available only if Syn is built with the "full" feature.

    Trait Implementations

    impl From<ExprRepeat> for Expr[src]

    impl ToTokens for ExprRepeat[src]

    Auto Trait Implementations

    Blanket Implementations

    impl<T> Any for T where
        T: 'static + ?Sized,     [src]

    impl<T> Borrow<T> for T where
        T: ?Sized,     [src]

    impl<T> BorrowMut<T> for T where
        T: ?Sized,     [src]

    impl<T> From<T> for T[src]

    impl<T, U> Into<U> for T where
        U: From<T>,     [src]

    Auto Trait Implementations

    Blanket Implementations

    impl<T> Any for T where
        T: 'static + ?Sized,     [src]

    impl<T> Borrow<T> for T where
        T: ?Sized,     [src]

    impl<T> BorrowMut<T> for T where
        T: ?Sized,     [src]

    impl<T> From<T> for T[src]

    impl<T, U> Into<U> for T where
        U: From<T>,     [src]

    impl<T> Spanned for T where
        T: Spanned + ?Sized,     [src]

    impl<T, U> TryFrom<U> for T where
        U: Into<T>,     [src]

    type Error = Infallible

    The type returned in the event of a conversion error.

    -

    impl<T, U> TryInto<U> for T where
        U: TryFrom<T>,     [src]

    type Error = <U as TryFrom<T>>::Error

    The type returned in the event of a conversion error.

    -
    \ No newline at end of file +

    impl<T, U> TryFrom<U> for T where
        U: Into<T>,     [src]

    type Error = Infallible

    The type returned in the event of a conversion error.

    +

    impl<T, U> TryInto<U> for T where
        U: TryFrom<T>,     [src]

    type Error = <U as TryFrom<T>>::Error

    The type returned in the event of a conversion error.

    +
    + \ No newline at end of file diff --git a/syn/struct.ExprReturn.html b/syn/struct.ExprReturn.html index a1cd8ae..a42bf85 100644 --- a/syn/struct.ExprReturn.html +++ b/syn/struct.ExprReturn.html @@ -1,21 +1,22 @@ -syn::ExprReturn - Rust +syn::ExprReturn - Rust -

    [−][src]Struct syn::ExprReturn

    pub struct ExprReturn { /* fields omitted */ }

    A return, with an optional value to be returned.

    +

    Struct syn::ExprReturn[−][src]

    pub struct ExprReturn { /* fields omitted */ }

    A return, with an optional value to be returned.

    This type is available only if Syn is built with the "full" feature.

    Trait Implementations

    impl From<ExprReturn> for Expr[src]

    impl ToTokens for ExprReturn[src]

    Auto Trait Implementations

    Blanket Implementations

    impl<T> Any for T where
        T: 'static + ?Sized,     [src]

    impl<T> Borrow<T> for T where
        T: ?Sized,     [src]

    impl<T> BorrowMut<T> for T where
        T: ?Sized,     [src]

    impl<T> From<T> for T[src]

    impl<T, U> Into<U> for T where
        U: From<T>,     [src]

    Auto Trait Implementations

    Blanket Implementations

    impl<T> Any for T where
        T: 'static + ?Sized,     [src]

    impl<T> Borrow<T> for T where
        T: ?Sized,     [src]

    impl<T> BorrowMut<T> for T where
        T: ?Sized,     [src]

    impl<T> From<T> for T[src]

    impl<T, U> Into<U> for T where
        U: From<T>,     [src]

    impl<T> Spanned for T where
        T: Spanned + ?Sized,     [src]

    impl<T, U> TryFrom<U> for T where
        U: Into<T>,     [src]

    type Error = Infallible

    The type returned in the event of a conversion error.

    -

    impl<T, U> TryInto<U> for T where
        U: TryFrom<T>,     [src]

    type Error = <U as TryFrom<T>>::Error

    The type returned in the event of a conversion error.

    -
    \ No newline at end of file +

    impl<T, U> TryFrom<U> for T where
        U: Into<T>,     [src]

    type Error = Infallible

    The type returned in the event of a conversion error.

    +

    impl<T, U> TryInto<U> for T where
        U: TryFrom<T>,     [src]

    type Error = <U as TryFrom<T>>::Error

    The type returned in the event of a conversion error.

    +
    + \ No newline at end of file diff --git a/syn/struct.ExprStruct.html b/syn/struct.ExprStruct.html index 829bdc0..f38893d 100644 --- a/syn/struct.ExprStruct.html +++ b/syn/struct.ExprStruct.html @@ -1,22 +1,23 @@ -syn::ExprStruct - Rust +syn::ExprStruct - Rust -

    [−][src]Struct syn::ExprStruct

    pub struct ExprStruct { /* fields omitted */ }

    A struct literal expression: Point { x: 1, y: 1 }.

    +

    Struct syn::ExprStruct[−][src]

    pub struct ExprStruct { /* fields omitted */ }

    A struct literal expression: Point { x: 1, y: 1 }.

    The rest provides the value of the remaining fields as in S { a: 1, b: 1, ..rest }.

    This type is available only if Syn is built with the "full" feature.

    Trait Implementations

    impl From<ExprStruct> for Expr[src]

    impl ToTokens for ExprStruct[src]

    Auto Trait Implementations

    Blanket Implementations

    impl<T> Any for T where
        T: 'static + ?Sized,     [src]

    impl<T> Borrow<T> for T where
        T: ?Sized,     [src]

    impl<T> BorrowMut<T> for T where
        T: ?Sized,     [src]

    impl<T> From<T> for T[src]

    impl<T, U> Into<U> for T where
        U: From<T>,     [src]

    Auto Trait Implementations

    Blanket Implementations

    impl<T> Any for T where
        T: 'static + ?Sized,     [src]

    impl<T> Borrow<T> for T where
        T: ?Sized,     [src]

    impl<T> BorrowMut<T> for T where
        T: ?Sized,     [src]

    impl<T> From<T> for T[src]

    impl<T, U> Into<U> for T where
        U: From<T>,     [src]

    impl<T> Spanned for T where
        T: Spanned + ?Sized,     [src]

    impl<T, U> TryFrom<U> for T where
        U: Into<T>,     [src]

    type Error = Infallible

    The type returned in the event of a conversion error.

    -

    impl<T, U> TryInto<U> for T where
        U: TryFrom<T>,     [src]

    type Error = <U as TryFrom<T>>::Error

    The type returned in the event of a conversion error.

    -
    \ No newline at end of file +

    impl<T, U> TryFrom<U> for T where
        U: Into<T>,     [src]

    type Error = Infallible

    The type returned in the event of a conversion error.

    +

    impl<T, U> TryInto<U> for T where
        U: TryFrom<T>,     [src]

    type Error = <U as TryFrom<T>>::Error

    The type returned in the event of a conversion error.

    +
    + \ No newline at end of file diff --git a/syn/struct.ExprTry.html b/syn/struct.ExprTry.html index ad55080..b4ea7f4 100644 --- a/syn/struct.ExprTry.html +++ b/syn/struct.ExprTry.html @@ -1,21 +1,22 @@ -syn::ExprTry - Rust +syn::ExprTry - Rust -

    [−][src]Struct syn::ExprTry

    pub struct ExprTry { /* fields omitted */ }

    A try-expression: expr?.

    +

    Struct syn::ExprTry[−][src]

    pub struct ExprTry { /* fields omitted */ }

    A try-expression: expr?.

    This type is available only if Syn is built with the "full" feature.

    Trait Implementations

    impl From<ExprTry> for Expr[src]

    impl ToTokens for ExprTry[src]

    Auto Trait Implementations

    Blanket Implementations

    impl<T> Any for T where
        T: 'static + ?Sized,     [src]

    impl<T> Borrow<T> for T where
        T: ?Sized,     [src]

    impl<T> BorrowMut<T> for T where
        T: ?Sized,     [src]

    impl<T> From<T> for T[src]

    impl<T, U> Into<U> for T where
        U: From<T>,     [src]

    Auto Trait Implementations

    impl RefUnwindSafe for ExprTry

    impl !Send for ExprTry

    impl !Sync for ExprTry

    impl Unpin for ExprTry

    impl UnwindSafe for ExprTry

    Blanket Implementations

    impl<T> Any for T where
        T: 'static + ?Sized,     [src]

    impl<T> Borrow<T> for T where
        T: ?Sized,     [src]

    impl<T> BorrowMut<T> for T where
        T: ?Sized,     [src]

    impl<T> From<T> for T[src]

    impl<T, U> Into<U> for T where
        U: From<T>,     [src]

    impl<T> Spanned for T where
        T: Spanned + ?Sized,     [src]

    impl<T, U> TryFrom<U> for T where
        U: Into<T>,     [src]

    type Error = Infallible

    The type returned in the event of a conversion error.

    -

    impl<T, U> TryInto<U> for T where
        U: TryFrom<T>,     [src]

    type Error = <U as TryFrom<T>>::Error

    The type returned in the event of a conversion error.

    -
    \ No newline at end of file +

    impl<T, U> TryFrom<U> for T where
        U: Into<T>,     [src]

    type Error = Infallible

    The type returned in the event of a conversion error.

    +

    impl<T, U> TryInto<U> for T where
        U: TryFrom<T>,     [src]

    type Error = <U as TryFrom<T>>::Error

    The type returned in the event of a conversion error.

    +
    + \ No newline at end of file diff --git a/syn/struct.ExprTryBlock.html b/syn/struct.ExprTryBlock.html index d0e8d27..8b08e7c 100644 --- a/syn/struct.ExprTryBlock.html +++ b/syn/struct.ExprTryBlock.html @@ -1,21 +1,22 @@ -syn::ExprTryBlock - Rust +syn::ExprTryBlock - Rust -

    [−][src]Struct syn::ExprTryBlock

    pub struct ExprTryBlock { /* fields omitted */ }

    A try block: try { ... }.

    +

    Struct syn::ExprTryBlock[−][src]

    pub struct ExprTryBlock { /* fields omitted */ }

    A try block: try { ... }.

    This type is available only if Syn is built with the "full" feature.

    Trait Implementations

    impl From<ExprTryBlock> for Expr[src]

    impl ToTokens for ExprTryBlock[src]

    Auto Trait Implementations

    Blanket Implementations

    impl<T> Any for T where
        T: 'static + ?Sized,     [src]

    impl<T> Borrow<T> for T where
        T: ?Sized,     [src]

    impl<T> BorrowMut<T> for T where
        T: ?Sized,     [src]

    impl<T> From<T> for T[src]

    impl<T, U> Into<U> for T where
        U: From<T>,     [src]

    Auto Trait Implementations

    Blanket Implementations

    impl<T> Any for T where
        T: 'static + ?Sized,     [src]

    impl<T> Borrow<T> for T where
        T: ?Sized,     [src]

    impl<T> BorrowMut<T> for T where
        T: ?Sized,     [src]

    impl<T> From<T> for T[src]

    impl<T, U> Into<U> for T where
        U: From<T>,     [src]

    impl<T> Spanned for T where
        T: Spanned + ?Sized,     [src]

    impl<T, U> TryFrom<U> for T where
        U: Into<T>,     [src]

    type Error = Infallible

    The type returned in the event of a conversion error.

    -

    impl<T, U> TryInto<U> for T where
        U: TryFrom<T>,     [src]

    type Error = <U as TryFrom<T>>::Error

    The type returned in the event of a conversion error.

    -
    \ No newline at end of file +

    impl<T, U> TryFrom<U> for T where
        U: Into<T>,     [src]

    type Error = Infallible

    The type returned in the event of a conversion error.

    +

    impl<T, U> TryInto<U> for T where
        U: TryFrom<T>,     [src]

    type Error = <U as TryFrom<T>>::Error

    The type returned in the event of a conversion error.

    +
    + \ No newline at end of file diff --git a/syn/struct.ExprTuple.html b/syn/struct.ExprTuple.html index b95872e..b11bc4c 100644 --- a/syn/struct.ExprTuple.html +++ b/syn/struct.ExprTuple.html @@ -1,21 +1,22 @@ -syn::ExprTuple - Rust +syn::ExprTuple - Rust -

    [−][src]Struct syn::ExprTuple

    pub struct ExprTuple { /* fields omitted */ }

    A tuple expression: (a, b, c, d).

    +

    Struct syn::ExprTuple[−][src]

    pub struct ExprTuple { /* fields omitted */ }

    A tuple expression: (a, b, c, d).

    This type is available only if Syn is built with the "full" feature.

    Trait Implementations

    impl From<ExprTuple> for Expr[src]

    impl ToTokens for ExprTuple[src]

    Auto Trait Implementations

    Blanket Implementations

    impl<T> Any for T where
        T: 'static + ?Sized,     [src]

    impl<T> Borrow<T> for T where
        T: ?Sized,     [src]

    impl<T> BorrowMut<T> for T where
        T: ?Sized,     [src]

    impl<T> From<T> for T[src]

    impl<T, U> Into<U> for T where
        U: From<T>,     [src]

    Auto Trait Implementations

    Blanket Implementations

    impl<T> Any for T where
        T: 'static + ?Sized,     [src]

    impl<T> Borrow<T> for T where
        T: ?Sized,     [src]

    impl<T> BorrowMut<T> for T where
        T: ?Sized,     [src]

    impl<T> From<T> for T[src]

    impl<T, U> Into<U> for T where
        U: From<T>,     [src]

    impl<T> Spanned for T where
        T: Spanned + ?Sized,     [src]

    impl<T, U> TryFrom<U> for T where
        U: Into<T>,     [src]

    type Error = Infallible

    The type returned in the event of a conversion error.

    -

    impl<T, U> TryInto<U> for T where
        U: TryFrom<T>,     [src]

    type Error = <U as TryFrom<T>>::Error

    The type returned in the event of a conversion error.

    -
    \ No newline at end of file +

    impl<T, U> TryFrom<U> for T where
        U: Into<T>,     [src]

    type Error = Infallible

    The type returned in the event of a conversion error.

    +

    impl<T, U> TryInto<U> for T where
        U: TryFrom<T>,     [src]

    type Error = <U as TryFrom<T>>::Error

    The type returned in the event of a conversion error.

    +
    + \ No newline at end of file diff --git a/syn/struct.ExprType.html b/syn/struct.ExprType.html index 35820b3..b996074 100644 --- a/syn/struct.ExprType.html +++ b/syn/struct.ExprType.html @@ -1,21 +1,22 @@ -syn::ExprType - Rust +syn::ExprType - Rust -

    [−][src]Struct syn::ExprType

    pub struct ExprType { /* fields omitted */ }

    A type ascription expression: foo: f64.

    +

    Struct syn::ExprType[−][src]

    pub struct ExprType { /* fields omitted */ }

    A type ascription expression: foo: f64.

    This type is available only if Syn is built with the "full" feature.

    Trait Implementations

    impl From<ExprType> for Expr[src]

    impl ToTokens for ExprType[src]

    Auto Trait Implementations

    Blanket Implementations

    impl<T> Any for T where
        T: 'static + ?Sized,     [src]

    impl<T> Borrow<T> for T where
        T: ?Sized,     [src]

    impl<T> BorrowMut<T> for T where
        T: ?Sized,     [src]

    impl<T> From<T> for T[src]

    impl<T, U> Into<U> for T where
        U: From<T>,     [src]

    Auto Trait Implementations

    impl RefUnwindSafe for ExprType

    impl !Send for ExprType

    impl !Sync for ExprType

    impl Unpin for ExprType

    impl UnwindSafe for ExprType

    Blanket Implementations

    impl<T> Any for T where
        T: 'static + ?Sized,     [src]

    impl<T> Borrow<T> for T where
        T: ?Sized,     [src]

    impl<T> BorrowMut<T> for T where
        T: ?Sized,     [src]

    impl<T> From<T> for T[src]

    impl<T, U> Into<U> for T where
        U: From<T>,     [src]

    impl<T> Spanned for T where
        T: Spanned + ?Sized,     [src]

    impl<T, U> TryFrom<U> for T where
        U: Into<T>,     [src]

    type Error = Infallible

    The type returned in the event of a conversion error.

    -

    impl<T, U> TryInto<U> for T where
        U: TryFrom<T>,     [src]

    type Error = <U as TryFrom<T>>::Error

    The type returned in the event of a conversion error.

    -
    \ No newline at end of file +

    impl<T, U> TryFrom<U> for T where
        U: Into<T>,     [src]

    type Error = Infallible

    The type returned in the event of a conversion error.

    +

    impl<T, U> TryInto<U> for T where
        U: TryFrom<T>,     [src]

    type Error = <U as TryFrom<T>>::Error

    The type returned in the event of a conversion error.

    +
    + \ No newline at end of file diff --git a/syn/struct.ExprUnary.html b/syn/struct.ExprUnary.html index 334358e..c17e872 100644 --- a/syn/struct.ExprUnary.html +++ b/syn/struct.ExprUnary.html @@ -1,7 +1,7 @@ -syn::ExprUnary - Rust +syn::ExprUnary - Rust -

    [−][src]Struct syn::ExprUnary

    pub struct ExprUnary {
+
    Struct syn::ExprUnary[−][src]
    pub struct ExprUnary {
     pub attrs: Vec<Attribute>,
     pub op: UnOp,
     pub expr: Box<Expr>,
@@ -10,30 +10,31 @@
 "full" feature.
    
 
    
                        Fields
    attrs: Vec<Attribute>op: UnOpexpr: Box<Expr>
    Trait Implementations
    impl Clone for ExprUnary[src]
    impl Debug for ExprUnary[src]
    impl Eq for ExprUnary[src]
    impl From<ExprUnary> for Expr[src]
    impl Hash for ExprUnary[src]
    impl PartialEq<ExprUnary> for ExprUnary[src]
    impl ToTokens for ExprUnary[src]
    Auto Trait Implementations
    Blanket Implementations
    impl<T> Any for T where
        T: 'static + ?Sized,     [src]
    impl<T> Borrow<T> for T where
        T: ?Sized,     [src]
    impl<T> BorrowMut<T> for T where
        T: ?Sized,     [src]
    impl<T> From<T> for T[src]
    impl<T, U> Into<U> for T where
        U: From<T>,     [src]
    impl ToTokens for ExprUnary[src]
    Auto Trait Implementations
    Blanket Implementations
    impl<T> Any for T where
        T: 'static + ?Sized,     [src]
    impl<T> Borrow<T> for T where
        T: ?Sized,     [src]
    impl<T> BorrowMut<T> for T where
        T: ?Sized,     [src]
    impl<T> From<T> for T[src]
    impl<T, U> Into<U> for T where
        U: From<T>,     [src]
    impl<T> Spanned for T where
        T: Spanned + ?Sized,     [src]
    impl<T> ToOwned for T where
        T: Clone,     [src]
    type Owned = T
    The resulting type after obtaining ownership.
    
-
    impl<T> ToOwned for T where
        T: Clone,     [src]
    type Owned = T
    The resulting type after obtaining ownership.
    
+
    impl<T, U> TryFrom<U> for T where
        U: Into<T>,     [src]
    type Error = Infallible
    The type returned in the event of a conversion error.
    
-
    impl<T, U> TryInto<U> for T where
        U: TryFrom<T>,     [src]
    type Error = <U as TryFrom<T>>::Error
    The type returned in the event of a conversion error.
    
-
    
\ No newline at end of file
+

    impl<T, U> TryFrom<U> for T where
        U: Into<T>,     [src]

    type Error = Infallible

    The type returned in the event of a conversion error.

    +

    impl<T, U> TryInto<U> for T where
        U: TryFrom<T>,     [src]

    type Error = <U as TryFrom<T>>::Error

    The type returned in the event of a conversion error.

    +
    + \ No newline at end of file diff --git a/syn/struct.ExprUnsafe.html b/syn/struct.ExprUnsafe.html index 399a81f..7c369b4 100644 --- a/syn/struct.ExprUnsafe.html +++ b/syn/struct.ExprUnsafe.html @@ -1,21 +1,22 @@ -syn::ExprUnsafe - Rust +syn::ExprUnsafe - Rust -

    [−][src]Struct syn::ExprUnsafe

    pub struct ExprUnsafe { /* fields omitted */ }

    An unsafe block: unsafe { ... }.

    +

    Struct syn::ExprUnsafe[−][src]

    pub struct ExprUnsafe { /* fields omitted */ }

    An unsafe block: unsafe { ... }.

    This type is available only if Syn is built with the "full" feature.

    Trait Implementations

    impl From<ExprUnsafe> for Expr[src]

    impl ToTokens for ExprUnsafe[src]

    Auto Trait Implementations

    Blanket Implementations

    impl<T> Any for T where
        T: 'static + ?Sized,     [src]

    impl<T> Borrow<T> for T where
        T: ?Sized,     [src]

    impl<T> BorrowMut<T> for T where
        T: ?Sized,     [src]

    impl<T> From<T> for T[src]

    impl<T, U> Into<U> for T where
        U: From<T>,     [src]

    Auto Trait Implementations

    Blanket Implementations

    impl<T> Any for T where
        T: 'static + ?Sized,     [src]

    impl<T> Borrow<T> for T where
        T: ?Sized,     [src]

    impl<T> BorrowMut<T> for T where
        T: ?Sized,     [src]

    impl<T> From<T> for T[src]

    impl<T, U> Into<U> for T where
        U: From<T>,     [src]

    impl<T> Spanned for T where
        T: Spanned + ?Sized,     [src]

    impl<T, U> TryFrom<U> for T where
        U: Into<T>,     [src]

    type Error = Infallible

    The type returned in the event of a conversion error.

    -

    impl<T, U> TryInto<U> for T where
        U: TryFrom<T>,     [src]

    type Error = <U as TryFrom<T>>::Error

    The type returned in the event of a conversion error.

    -
    \ No newline at end of file +

    impl<T, U> TryFrom<U> for T where
        U: Into<T>,     [src]

    type Error = Infallible

    The type returned in the event of a conversion error.

    +

    impl<T, U> TryInto<U> for T where
        U: TryFrom<T>,     [src]

    type Error = <U as TryFrom<T>>::Error

    The type returned in the event of a conversion error.

    +
    + \ No newline at end of file diff --git a/syn/struct.ExprWhile.html b/syn/struct.ExprWhile.html index 117beba..1348bed 100644 --- a/syn/struct.ExprWhile.html +++ b/syn/struct.ExprWhile.html @@ -1,21 +1,22 @@ -syn::ExprWhile - Rust +syn::ExprWhile - Rust -

    [−][src]Struct syn::ExprWhile

    pub struct ExprWhile { /* fields omitted */ }

    A while loop: while expr { ... }.

    +

    Struct syn::ExprWhile[−][src]

    pub struct ExprWhile { /* fields omitted */ }

    A while loop: while expr { ... }.

    This type is available only if Syn is built with the "full" feature.

    Trait Implementations

    impl From<ExprWhile> for Expr[src]

    impl ToTokens for ExprWhile[src]

    Auto Trait Implementations

    Blanket Implementations

    impl<T> Any for T where
        T: 'static + ?Sized,     [src]

    impl<T> Borrow<T> for T where
        T: ?Sized,     [src]

    impl<T> BorrowMut<T> for T where
        T: ?Sized,     [src]

    impl<T> From<T> for T[src]

    impl<T, U> Into<U> for T where
        U: From<T>,     [src]

    Auto Trait Implementations

    Blanket Implementations

    impl<T> Any for T where
        T: 'static + ?Sized,     [src]

    impl<T> Borrow<T> for T where
        T: ?Sized,     [src]

    impl<T> BorrowMut<T> for T where
        T: ?Sized,     [src]

    impl<T> From<T> for T[src]

    impl<T, U> Into<U> for T where
        U: From<T>,     [src]

    impl<T> Spanned for T where
        T: Spanned + ?Sized,     [src]

    impl<T, U> TryFrom<U> for T where
        U: Into<T>,     [src]

    type Error = Infallible

    The type returned in the event of a conversion error.

    -

    impl<T, U> TryInto<U> for T where
        U: TryFrom<T>,     [src]

    type Error = <U as TryFrom<T>>::Error

    The type returned in the event of a conversion error.

    -
    \ No newline at end of file +

    impl<T, U> TryFrom<U> for T where
        U: Into<T>,     [src]

    type Error = Infallible

    The type returned in the event of a conversion error.

    +

    impl<T, U> TryInto<U> for T where
        U: TryFrom<T>,     [src]

    type Error = <U as TryFrom<T>>::Error

    The type returned in the event of a conversion error.

    +
    + \ No newline at end of file diff --git a/syn/struct.ExprYield.html b/syn/struct.ExprYield.html index 768bd22..316edf8 100644 --- a/syn/struct.ExprYield.html +++ b/syn/struct.ExprYield.html @@ -1,21 +1,22 @@ -syn::ExprYield - Rust +syn::ExprYield - Rust -

    [−][src]Struct syn::ExprYield

    pub struct ExprYield { /* fields omitted */ }

    A yield expression: yield expr.

    +

    Struct syn::ExprYield[−][src]

    pub struct ExprYield { /* fields omitted */ }

    A yield expression: yield expr.

    This type is available only if Syn is built with the "full" feature.

    Trait Implementations

    impl From<ExprYield> for Expr[src]

    impl ToTokens for ExprYield[src]

    Auto Trait Implementations

    Blanket Implementations

    impl<T> Any for T where
        T: 'static + ?Sized,     [src]

    impl<T> Borrow<T> for T where
        T: ?Sized,     [src]

    impl<T> BorrowMut<T> for T where
        T: ?Sized,     [src]

    impl<T> From<T> for T[src]

    impl<T, U> Into<U> for T where
        U: From<T>,     [src]

    Auto Trait Implementations

    Blanket Implementations

    impl<T> Any for T where
        T: 'static + ?Sized,     [src]

    impl<T> Borrow<T> for T where
        T: ?Sized,     [src]

    impl<T> BorrowMut<T> for T where
        T: ?Sized,     [src]

    impl<T> From<T> for T[src]

    impl<T, U> Into<U> for T where
        U: From<T>,     [src]

    impl<T> Spanned for T where
        T: Spanned + ?Sized,     [src]

    impl<T, U> TryFrom<U> for T where
        U: Into<T>,     [src]

    type Error = Infallible

    The type returned in the event of a conversion error.

    -

    impl<T, U> TryInto<U> for T where
        U: TryFrom<T>,     [src]

    type Error = <U as TryFrom<T>>::Error

    The type returned in the event of a conversion error.

    -
    \ No newline at end of file +

    impl<T, U> TryFrom<U> for T where
        U: Into<T>,     [src]

    type Error = Infallible

    The type returned in the event of a conversion error.

    +

    impl<T, U> TryInto<U> for T where
        U: TryFrom<T>,     [src]

    type Error = <U as TryFrom<T>>::Error

    The type returned in the event of a conversion error.

    +
    + \ No newline at end of file diff --git a/syn/struct.Field.html b/syn/struct.Field.html index 28a93df..9c777b2 100644 --- a/syn/struct.Field.html +++ b/syn/struct.Field.html @@ -1,7 +1,7 @@ -syn::Field - Rust +syn::Field - Rust -

    [−][src]Struct syn::Field

    pub struct Field {
+
    Struct syn::Field[−][src]
    pub struct Field {
     pub attrs: Vec<Attribute>,
     pub vis: Visibility,
     pub ident: Option<Ident>,
@@ -16,32 +16,33 @@ feature.
    
 
    ident: Option<Ident>
    Name of the field, if any.
    
 
    Fields of tuple structs have no names.
    
 
    colon_token: Option<Colon>ty: Type
    Type of the field.
    
-
    Implementations
    impl Field[src]
    pub fn parse_named(input: ParseStream<'_>) -> Result<Self>[src]
    Parses a named (braced struct) field.
    
-
    pub fn parse_unnamed(input: ParseStream<'_>) -> Result<Self>[src]
    Parses an unnamed (tuple struct) field.
    
+
    Implementations
    impl Field[src]
    pub fn parse_named(input: ParseStream<'_>) -> Result<Self>[src]
    Parses a named (braced struct) field.
    
+
    pub fn parse_unnamed(input: ParseStream<'_>) -> Result<Self>[src]
    Parses an unnamed (tuple struct) field.
    
 
    Trait Implementations
    impl Clone for Field[src]
    impl Debug for Field[src]
    impl Eq for Field[src]
    impl Hash for Field[src]
    impl PartialEq<Field> for Field[src]
    impl ToTokens for Field[src]
    Auto Trait Implementations
    Blanket Implementations
    impl<T> Any for T where
        T: 'static + ?Sized,     [src]
    impl<T> Borrow<T> for T where
        T: ?Sized,     [src]
    impl<T> BorrowMut<T> for T where
        T: ?Sized,     [src]
    impl<T> From<T> for T[src]
    impl<T, U> Into<U> for T where
        U: From<T>,     [src]
    impl ToTokens for Field[src]
    Auto Trait Implementations
    impl RefUnwindSafe for Field
    impl !Send for Field
    impl !Sync for Field
    impl Unpin for Field
    impl UnwindSafe for Field
    Blanket Implementations
    impl<T> Any for T where
        T: 'static + ?Sized,     [src]
    impl<T> Borrow<T> for T where
        T: ?Sized,     [src]
    impl<T> BorrowMut<T> for T where
        T: ?Sized,     [src]
    impl<T> From<T> for T[src]
    impl<T, U> Into<U> for T where
        U: From<T>,     [src]
    impl<T> Spanned for T where
        T: Spanned + ?Sized,     [src]
    impl<T> ToOwned for T where
        T: Clone,     [src]
    type Owned = T
    The resulting type after obtaining ownership.
    
-
    impl<T> ToOwned for T where
        T: Clone,     [src]
    type Owned = T
    The resulting type after obtaining ownership.
    
+
    impl<T, U> TryFrom<U> for T where
        U: Into<T>,     [src]
    type Error = Infallible
    The type returned in the event of a conversion error.
    
-
    impl<T, U> TryInto<U> for T where
        U: TryFrom<T>,     [src]
    type Error = <U as TryFrom<T>>::Error
    The type returned in the event of a conversion error.
    
-
    
\ No newline at end of file
+

    impl<T, U> TryFrom<U> for T where
        U: Into<T>,     [src]

    type Error = Infallible

    The type returned in the event of a conversion error.

    +

    impl<T, U> TryInto<U> for T where
        U: TryFrom<T>,     [src]

    type Error = <U as TryFrom<T>>::Error

    The type returned in the event of a conversion error.

    +
    + \ No newline at end of file diff --git a/syn/struct.FieldsNamed.html b/syn/struct.FieldsNamed.html index b7edec1..f1c4f5d 100644 --- a/syn/struct.FieldsNamed.html +++ b/syn/struct.FieldsNamed.html @@ -1,7 +1,7 @@ -syn::FieldsNamed - Rust +syn::FieldsNamed - Rust -

    [−][src]Struct syn::FieldsNamed

    pub struct FieldsNamed {
+
    Struct syn::FieldsNamed[−][src]
    pub struct FieldsNamed {
     pub brace_token: Brace,
     pub named: Punctuated<Field, Comma>,
 }
    Named fields of a struct or struct variant such as Point { x: f64, y: f64 }.
    
@@ -9,30 +9,31 @@
 "full" feature.
    
 
    
                        Fields
    brace_token: Bracenamed: Punctuated<Field, Comma>
    Trait Implementations
    impl Clone for FieldsNamed[src]
    impl Debug for FieldsNamed[src]
    impl Eq for FieldsNamed[src]
    impl From<FieldsNamed> for Fields[src]
    impl Hash for FieldsNamed[src]
    impl Parse for FieldsNamed[src]
    impl PartialEq<FieldsNamed> for FieldsNamed[src]
    impl ToTokens for FieldsNamed[src]
    Auto Trait Implementations
    Blanket Implementations
    impl<T> Any for T where
        T: 'static + ?Sized,     [src]
    impl<T> Borrow<T> for T where
        T: ?Sized,     [src]
    impl<T> BorrowMut<T> for T where
        T: ?Sized,     [src]
    impl<T> From<T> for T[src]
    impl<T, U> Into<U> for T where
        U: From<T>,     [src]
    impl ToTokens for FieldsNamed[src]
    Auto Trait Implementations
    Blanket Implementations
    impl<T> Any for T where
        T: 'static + ?Sized,     [src]
    impl<T> Borrow<T> for T where
        T: ?Sized,     [src]
    impl<T> BorrowMut<T> for T where
        T: ?Sized,     [src]
    impl<T> From<T> for T[src]
    impl<T, U> Into<U> for T where
        U: From<T>,     [src]
    impl<T> Spanned for T where
        T: Spanned + ?Sized,     [src]
    impl<T> ToOwned for T where
        T: Clone,     [src]
    type Owned = T
    The resulting type after obtaining ownership.
    
-
    impl<T> ToOwned for T where
        T: Clone,     [src]
    type Owned = T
    The resulting type after obtaining ownership.
    
+
    impl<T, U> TryFrom<U> for T where
        U: Into<T>,     [src]
    type Error = Infallible
    The type returned in the event of a conversion error.
    
-
    impl<T, U> TryInto<U> for T where
        U: TryFrom<T>,     [src]
    type Error = <U as TryFrom<T>>::Error
    The type returned in the event of a conversion error.
    
-
    
\ No newline at end of file
+

    impl<T, U> TryFrom<U> for T where
        U: Into<T>,     [src]

    type Error = Infallible

    The type returned in the event of a conversion error.

    +

    impl<T, U> TryInto<U> for T where
        U: TryFrom<T>,     [src]

    type Error = <U as TryFrom<T>>::Error

    The type returned in the event of a conversion error.

    +
    + \ No newline at end of file diff --git a/syn/struct.FieldsUnnamed.html b/syn/struct.FieldsUnnamed.html index fad97e6..91d8ea7 100644 --- a/syn/struct.FieldsUnnamed.html +++ b/syn/struct.FieldsUnnamed.html @@ -1,7 +1,7 @@ -syn::FieldsUnnamed - Rust +syn::FieldsUnnamed - Rust -

    [−][src]Struct syn::FieldsUnnamed

    pub struct FieldsUnnamed {
+
    Struct syn::FieldsUnnamed[−][src]
    pub struct FieldsUnnamed {
     pub paren_token: Paren,
     pub unnamed: Punctuated<Field, Comma>,
 }
    Unnamed fields of a tuple struct or tuple variant such as Some(T).
    
@@ -9,30 +9,31 @@
 "full" feature.
    
 
    
                        Fields
    paren_token: Parenunnamed: Punctuated<Field, Comma>
    Trait Implementations
    impl Clone for FieldsUnnamed[src]
    impl Debug for FieldsUnnamed[src]
    impl Eq for FieldsUnnamed[src]
    impl From<FieldsUnnamed> for Fields[src]
    impl Hash for FieldsUnnamed[src]
    impl Parse for FieldsUnnamed[src]
    impl PartialEq<FieldsUnnamed> for FieldsUnnamed[src]
    impl ToTokens for FieldsUnnamed[src]
    Auto Trait Implementations
    Blanket Implementations
    impl<T> Any for T where
        T: 'static + ?Sized,     [src]
    impl<T> Borrow<T> for T where
        T: ?Sized,     [src]
    impl<T> BorrowMut<T> for T where
        T: ?Sized,     [src]
    impl<T> From<T> for T[src]
    impl<T, U> Into<U> for T where
        U: From<T>,     [src]
    impl ToTokens for FieldsUnnamed[src]
    Auto Trait Implementations
    Blanket Implementations
    impl<T> Any for T where
        T: 'static + ?Sized,     [src]
    impl<T> Borrow<T> for T where
        T: ?Sized,     [src]
    impl<T> BorrowMut<T> for T where
        T: ?Sized,     [src]
    impl<T> From<T> for T[src]
    impl<T, U> Into<U> for T where
        U: From<T>,     [src]
    impl<T> Spanned for T where
        T: Spanned + ?Sized,     [src]
    impl<T> ToOwned for T where
        T: Clone,     [src]
    type Owned = T
    The resulting type after obtaining ownership.
    
-
    impl<T> ToOwned for T where
        T: Clone,     [src]
    type Owned = T
    The resulting type after obtaining ownership.
    
+
    impl<T, U> TryFrom<U> for T where
        U: Into<T>,     [src]
    type Error = Infallible
    The type returned in the event of a conversion error.
    
-
    impl<T, U> TryInto<U> for T where
        U: TryFrom<T>,     [src]
    type Error = <U as TryFrom<T>>::Error
    The type returned in the event of a conversion error.
    
-
    
\ No newline at end of file
+

    impl<T, U> TryFrom<U> for T where
        U: Into<T>,     [src]

    type Error = Infallible

    The type returned in the event of a conversion error.

    +

    impl<T, U> TryInto<U> for T where
        U: TryFrom<T>,     [src]

    type Error = <U as TryFrom<T>>::Error

    The type returned in the event of a conversion error.

    +
    + \ No newline at end of file diff --git a/syn/struct.Generics.html b/syn/struct.Generics.html index 664cd97..8718978 100644 --- a/syn/struct.Generics.html +++ b/syn/struct.Generics.html @@ -1,7 +1,7 @@ -syn::Generics - Rust +syn::Generics - Rust -

    [−][src]Struct syn::Generics

    pub struct Generics {
+
    Struct syn::Generics[−][src]
    pub struct Generics {
     pub lt_token: Option<Lt>,
     pub params: Punctuated<GenericParam, Comma>,
     pub gt_token: Option<Gt>,
@@ -11,7 +11,7 @@ enum, trait, etc.
    
 
    This type is available only if Syn is built with the "derive" or "full"
 feature.
    
 
    
-                       Fields
    lt_token: Option<Lt>params: Punctuated<GenericParam, Comma>gt_token: Option<Gt>where_clause: Option<WhereClause>
    Implementations
    impl Generics[src]
    pub fn type_params(&self) -> TypeParams<'_>[src]
    Returns an
+                       Fieldslt_token: Option<Lt>params: Punctuated<GenericParam, Comma>gt_token: Option<Gt>where_clause: Option<WhereClause>
    Implementations
    impl Generics[src]
    pub fn type_params(&self) -> TypeParams<'_>[src]
    Returns an
 Iterator<Item = &self.params.
    
   style="padding-left:0;padding-right:0;">ConstParam>
 over the constant parameters in self.params.
    
-
    pub fn make_where_clause(&mut self) -> &mut WhereClause[src]
    Initializes an empty where-clause if there is not one present already.
    
-
    impl Generics[src]
    pub fn split_for_impl(
        &self
    ) -> (ImplGenerics<'_>, TypeGenerics<'_>, Option<&WhereClause>)    [src]
    Split a type's generics into the pieces required for impl'ing a trait
+
    pub fn make_where_clause(&mut self) -> &mut WhereClause[src]
    Initializes an empty where-clause if there is not one present already.
    
+
    impl Generics[src]
    pub fn split_for_impl(
        &self
    ) -> (ImplGenerics<'_>, TypeGenerics<'_>, Option<&WhereClause>)    [src]
    Split a type’s generics into the pieces required for impl’ing a trait
 for that type.
    
 
 
    @@ -67,30 +67,31 @@ for that type.
    
 
    This method is available only if Syn is built with the "derive" or
 "full" feature and the "printing" feature.
    
 
    Trait Implementations
    impl Clone for Generics[src]
    impl Debug for Generics[src]
    impl Default for Generics[src]
    impl Default for Generics[src]
    impl Eq for Generics[src]
    impl Hash for Generics[src]
    impl Parse for Generics[src]
    impl PartialEq<Generics> for Generics[src]
    impl Parse for Generics[src]
    impl PartialEq<Generics> for Generics[src]
    impl ToTokens for Generics[src]
    Auto Trait Implementations
    Blanket Implementations
    impl<T> Any for T where
        T: 'static + ?Sized,     [src]
    impl<T> Borrow<T> for T where
        T: ?Sized,     [src]
    impl<T> BorrowMut<T> for T where
        T: ?Sized,     [src]
    impl<T> From<T> for T[src]
    impl<T, U> Into<U> for T where
        U: From<T>,     [src]
    impl ToTokens for Generics[src]
    Auto Trait Implementations
    impl RefUnwindSafe for Generics
    impl !Send for Generics
    impl !Sync for Generics
    impl Unpin for Generics
    impl UnwindSafe for Generics
    Blanket Implementations
    impl<T> Any for T where
        T: 'static + ?Sized,     [src]
    impl<T> Borrow<T> for T where
        T: ?Sized,     [src]
    impl<T> BorrowMut<T> for T where
        T: ?Sized,     [src]
    impl<T> From<T> for T[src]
    impl<T, U> Into<U> for T where
        U: From<T>,     [src]
    impl<T> Spanned for T where
        T: Spanned + ?Sized,     [src]
    impl<T> ToOwned for T where
        T: Clone,     [src]
    type Owned = T
    The resulting type after obtaining ownership.
    
-
    impl<T> ToOwned for T where
        T: Clone,     [src]
    type Owned = T
    The resulting type after obtaining ownership.
    
+
    impl<T, U> TryFrom<U> for T where
        U: Into<T>,     [src]
    type Error = Infallible
    The type returned in the event of a conversion error.
    
-
    impl<T, U> TryInto<U> for T where
        U: TryFrom<T>,     [src]
    type Error = <U as TryFrom<T>>::Error
    The type returned in the event of a conversion error.
    
-
    
\ No newline at end of file
+

    impl<T, U> TryFrom<U> for T where
        U: Into<T>,     [src]

    type Error = Infallible

    The type returned in the event of a conversion error.

    +

    impl<T, U> TryInto<U> for T where
        U: TryFrom<T>,     [src]

    type Error = <U as TryFrom<T>>::Error

    The type returned in the event of a conversion error.

    +
    + \ No newline at end of file diff --git a/syn/struct.Ident.html b/syn/struct.Ident.html index 380f9a8..f3a68f6 100644 --- a/syn/struct.Ident.html +++ b/syn/struct.Ident.html @@ -1,7 +1,7 @@ -syn::Ident - Rust +syn::Ident - Rust -

    [−][src]Struct syn::Ident

    pub struct Ident { /* fields omitted */ }

    A word of Rust code, which may be a keyword or legal variable name.

    +

    Struct syn::Ident[−][src]

    pub struct Ident { /* fields omitted */ }

    A word of Rust code, which may be a keyword or legal variable name.

    An identifier consists of at least one Unicode code point, the first of which has the XID_Start property and the rest of which have the XID_Continue property.

    @@ -51,18 +51,18 @@ method.

    if ident_string.len() > 60 { println!("Very long identifier: {}", ident_string) }
    -

    Implementations

    impl Ident[src]

    pub fn new(string: &str, span: Span) -> Ident[src]

    Creates a new Ident with the given string as well as the specified +

    Implementations

    impl Ident[src]

    pub fn new(string: &str, span: Span) -> Ident[src]

    Creates a new Ident with the given string as well as the specified span.

    The string argument must be a valid identifier permitted by the language, otherwise the function will panic.

    Note that span, currently in rustc, configures the hygiene information for this identifier.

    -

    As of this time Span::call_site() explicitly opts-in to "call-site" +

    As of this time Span::call_site() explicitly opts-in to “call-site” hygiene meaning that identifiers created with this span will be resolved as if they were written directly at the location of the macro call, and other code at the macro call site will be able to refer to them as well.

    Later spans like Span::def_site() will allow to opt-in to -"definition-site" hygiene meaning that identifiers created with this +“definition-site” hygiene meaning that identifiers created with this span will be resolved at the location of the macro definition and other code at the macro call site will not be able to refer to them.

    Due to the current importance of hygiene this constructor, unlike other @@ -75,65 +75,67 @@ need to handle an error case, use style="padding-right:0;">syn::parse_str::<Ident> rather than Ident::new.

    -

    pub fn span(&self) -> Span[src]

    Returns the span of this Ident.

    -

    pub fn set_span(&mut self, span: Span)[src]

    Configures the span of this Ident, possibly changing its hygiene +

    pub fn span(&self) -> Span[src]

    Returns the span of this Ident.

    +

    pub fn set_span(&mut self, span: Span)[src]

    Configures the span of this Ident, possibly changing its hygiene context.

    -

    Trait Implementations

    impl Clone for Ident[src]

    impl Debug for Ident[src]

    impl Display for Ident[src]

    Prints the identifier as a string that should be losslessly convertible back +

    Trait Implementations

    impl Clone for Ident[src]

    impl Debug for Ident[src]

    impl Display for Ident[src]

    Prints the identifier as a string that should be losslessly convertible back into the same identifier.

    -

    impl Eq for Ident[src]

    impl From<Crate> for Ident[src]

    impl Eq for Ident[src]

    impl From<Crate> for Ident[src]

    impl From<Extern> for Ident[src]

    impl From<Ident> for TokenTree[src]

    impl From<Ident> for TypeParam[src]

    impl From<Ident> for TokenTree[src]

    impl From<Ident> for Member[src]

    impl From<Ident> for TypeParam[src]

    impl From<SelfType> for Ident[src]

    impl From<SelfValue> for Ident[src]

    impl From<Super> for Ident[src]

    impl From<Underscore> for Ident[src]

    impl Hash for Ident[src]

    impl Hash for Ident[src]

    impl IdentExt for Ident[src]

    impl IdentFragment for Ident[src]

    impl Ord for Ident[src]

    impl Parse for Ident[src]

    impl PartialEq<Ident> for Ident[src]

    impl IdentFragment for Ident[src]

    impl Ord for Ident[src]

    impl Parse for Ident[src]

    impl PartialEq<Ident> for Ident[src]

    impl<T> PartialEq<T> for Ident where
        T: AsRef<str> + ?Sized,     [src]

    impl<T> PartialEq<T> for Ident where
        T: AsRef<str> + ?Sized,     [src]

    impl PartialOrd<Ident> for Ident[src]

    impl PartialOrd<Ident> for Ident[src]

    impl ToTokens for Ident[src]

    impl Token for Ident[src]

    Auto Trait Implementations

    Blanket Implementations

    impl<T> Any for T where
        T: 'static + ?Sized,     [src]

    impl<T> Borrow<T> for T where
        T: ?Sized,     [src]

    impl<T> BorrowMut<T> for T where
        T: ?Sized,     [src]

    impl<T> From<T> for T[src]

    impl<T, U> Into<U> for T where
        U: From<T>,     [src]

    impl ToTokens for Ident[src]

    impl Token for Ident[src]

    Auto Trait Implementations

    impl RefUnwindSafe for Ident

    impl !Send for Ident

    impl !Sync for Ident

    impl Unpin for Ident

    impl UnwindSafe for Ident

    Blanket Implementations

    impl<T> Any for T where
        T: 'static + ?Sized,     [src]

    impl<T> Borrow<T> for T where
        T: ?Sized,     [src]

    impl<T> BorrowMut<T> for T where
        T: ?Sized,     [src]

    impl<T> From<T> for T[src]

    impl<T, U> Into<U> for T where
        U: From<T>,     [src]

    impl<T> Spanned for T where
        T: Spanned + ?Sized,     [src]

    impl<T> ToOwned for T where
        T: Clone,     [src]

    type Owned = T

    The resulting type after obtaining ownership.

    -

    impl<T> ToOwned for T where
        T: Clone,     [src]

    type Owned = T

    The resulting type after obtaining ownership.

    +

    impl<T> ToString for T where
        T: Display + ?Sized,     [src]

    impl<T, U> TryFrom<U> for T where
        U: Into<T>,     [src]

    type Error = Infallible

    The type returned in the event of a conversion error.

    -

    impl<T, U> TryInto<U> for T where
        U: TryFrom<T>,     [src]

    type Error = <U as TryFrom<T>>::Error

    The type returned in the event of a conversion error.

    -
    \ No newline at end of file +

    impl<T> ToString for T where
        T: Display + ?Sized,     [src]

    impl<T, U> TryFrom<U> for T where
        U: Into<T>,     [src]

    type Error = Infallible

    The type returned in the event of a conversion error.

    +

    impl<T, U> TryInto<U> for T where
        U: TryFrom<T>,     [src]

    type Error = <U as TryFrom<T>>::Error

    The type returned in the event of a conversion error.

    +
    + \ No newline at end of file diff --git a/syn/struct.ImplGenerics.html b/syn/struct.ImplGenerics.html index e4aaf70..d94fef0 100644 --- a/syn/struct.ImplGenerics.html +++ b/syn/struct.ImplGenerics.html @@ -1,33 +1,34 @@ -syn::ImplGenerics - Rust +syn::ImplGenerics - Rust -

    [−][src]Struct syn::ImplGenerics

    pub struct ImplGenerics<'a>(_);

    Returned by Generics::split_for_impl.

    +

    Struct syn::ImplGenerics[−][src]

    pub struct ImplGenerics<'a>(_);

    Returned by Generics::split_for_impl.

    This type is available only if Syn is built with the "derive" or "full" feature and the "printing" feature.

    -

    Trait Implementations

    impl<'a> Clone for ImplGenerics<'a>[src]

    impl<'a> Debug for ImplGenerics<'a>[src]

    impl<'a> Eq for ImplGenerics<'a>[src]

    impl<'a> Hash for ImplGenerics<'a>[src]

    impl<'a> PartialEq<ImplGenerics<'a>> for ImplGenerics<'a>[src]

    Trait Implementations

    impl<'a> Clone for ImplGenerics<'a>[src]

    impl<'a> Debug for ImplGenerics<'a>[src]

    impl<'a> Eq for ImplGenerics<'a>[src]

    impl<'a> Hash for ImplGenerics<'a>[src]

    impl<'a> PartialEq<ImplGenerics<'a>> for ImplGenerics<'a>[src]

    impl<'a> ToTokens for ImplGenerics<'a>[src]

    Auto Trait Implementations

    impl<'a> RefUnwindSafe for ImplGenerics<'a>[src]

    impl<'a> !Send for ImplGenerics<'a>[src]

    impl<'a> !Sync for ImplGenerics<'a>[src]

    impl<'a> Unpin for ImplGenerics<'a>[src]

    impl<'a> UnwindSafe for ImplGenerics<'a>[src]

    Blanket Implementations

    impl<T> Any for T where
        T: 'static + ?Sized,     [src]

    impl<T> Borrow<T> for T where
        T: ?Sized,     [src]

    impl<T> BorrowMut<T> for T where
        T: ?Sized,     [src]

    impl<T> From<T> for T[src]

    impl<T, U> Into<U> for T where
        U: From<T>,     [src]

    impl<'a> ToTokens for ImplGenerics<'a>[src]

    Auto Trait Implementations

    impl<'a> RefUnwindSafe for ImplGenerics<'a>

    impl<'a> !Send for ImplGenerics<'a>

    impl<'a> !Sync for ImplGenerics<'a>

    impl<'a> Unpin for ImplGenerics<'a>

    impl<'a> UnwindSafe for ImplGenerics<'a>

    Blanket Implementations

    impl<T> Any for T where
        T: 'static + ?Sized,     [src]

    impl<T> Borrow<T> for T where
        T: ?Sized,     [src]

    impl<T> BorrowMut<T> for T where
        T: ?Sized,     [src]

    impl<T> From<T> for T[src]

    impl<T, U> Into<U> for T where
        U: From<T>,     [src]

    impl<T> Spanned for T where
        T: Spanned + ?Sized,     [src]

    impl<T> ToOwned for T where
        T: Clone,     [src]

    type Owned = T

    The resulting type after obtaining ownership.

    -

    impl<T> ToOwned for T where
        T: Clone,     [src]

    type Owned = T

    The resulting type after obtaining ownership.

    +

    impl<T, U> TryFrom<U> for T where
        U: Into<T>,     [src]

    type Error = Infallible

    The type returned in the event of a conversion error.

    -

    impl<T, U> TryInto<U> for T where
        U: TryFrom<T>,     [src]

    type Error = <U as TryFrom<T>>::Error

    The type returned in the event of a conversion error.

    -
    \ No newline at end of file +

    impl<T, U> TryFrom<U> for T where
        U: Into<T>,     [src]

    type Error = Infallible

    The type returned in the event of a conversion error.

    +

    impl<T, U> TryInto<U> for T where
        U: TryFrom<T>,     [src]

    type Error = <U as TryFrom<T>>::Error

    The type returned in the event of a conversion error.

    +
    + \ No newline at end of file diff --git a/syn/struct.Index.html b/syn/struct.Index.html index 0736429..7359b4c 100644 --- a/syn/struct.Index.html +++ b/syn/struct.Index.html @@ -1,7 +1,7 @@ -syn::Index - Rust +syn::Index - Rust -

    [−][src]Struct syn::Index

    pub struct Index {
+
    Struct syn::Index[−][src]
    pub struct Index {
     pub index: u32,
     pub span: Span,
 }
    The index of an unnamed tuple struct field.
    
@@ -9,32 +9,34 @@
 feature.
    
 
    
                        Fields
    index: u32span: Span
    Trait Implementations
    impl Clone for Index[src]
    impl Debug for Index[src]
    impl Eq for Index[src]
    impl From<usize> for Index[src]
    impl Hash for Index[src]
    impl IdentFragment for Index[src]
    impl Parse for Index[src]
    impl PartialEq<Index> for Index[src]
    impl Eq for Index[src]
    impl From<Index> for Member[src]
    impl From<usize> for Index[src]
    impl Hash for Index[src]
    impl IdentFragment for Index[src]
    impl Parse for Index[src]
    impl PartialEq<Index> for Index[src]
    impl ToTokens for Index[src]
    Auto Trait Implementations
    Blanket Implementations
    impl<T> Any for T where
        T: 'static + ?Sized,     [src]
    impl<T> Borrow<T> for T where
        T: ?Sized,     [src]
    impl<T> BorrowMut<T> for T where
        T: ?Sized,     [src]
    impl<T> From<T> for T[src]
    impl<T, U> Into<U> for T where
        U: From<T>,     [src]
    impl ToTokens for Index[src]
    Auto Trait Implementations
    impl RefUnwindSafe for Index
    impl !Send for Index
    impl !Sync for Index
    impl Unpin for Index
    impl UnwindSafe for Index
    Blanket Implementations
    impl<T> Any for T where
        T: 'static + ?Sized,     [src]
    impl<T> Borrow<T> for T where
        T: ?Sized,     [src]
    impl<T> BorrowMut<T> for T where
        T: ?Sized,     [src]
    impl<T> From<T> for T[src]
    impl<T, U> Into<U> for T where
        U: From<T>,     [src]
    impl<T> Spanned for T where
        T: Spanned + ?Sized,     [src]
    impl<T> ToOwned for T where
        T: Clone,     [src]
    type Owned = T
    The resulting type after obtaining ownership.
    
-
    impl<T> ToOwned for T where
        T: Clone,     [src]
    type Owned = T
    The resulting type after obtaining ownership.
    
+
    impl<T, U> TryFrom<U> for T where
        U: Into<T>,     [src]
    type Error = Infallible
    The type returned in the event of a conversion error.
    
-
    impl<T, U> TryInto<U> for T where
        U: TryFrom<T>,     [src]
    type Error = <U as TryFrom<T>>::Error
    The type returned in the event of a conversion error.
    
-
    
\ No newline at end of file
+

    impl<T, U> TryFrom<U> for T where
        U: Into<T>,     [src]

    type Error = Infallible

    The type returned in the event of a conversion error.

    +

    impl<T, U> TryInto<U> for T where
        U: TryFrom<T>,     [src]

    type Error = <U as TryFrom<T>>::Error

    The type returned in the event of a conversion error.

    +
    + \ No newline at end of file diff --git a/syn/struct.Lifetime.html b/syn/struct.Lifetime.html index ef7e982..b35e61a 100644 --- a/syn/struct.Lifetime.html +++ b/syn/struct.Lifetime.html @@ -1,7 +1,7 @@ -syn::Lifetime - Rust +syn::Lifetime - Rust -

    [−][src]Struct syn::Lifetime

    pub struct Lifetime {
+
    Struct syn::Lifetime[−][src]
    pub struct Lifetime {
     pub apostrophe: Span,
     pub ident: Ident,
 }
    A Rust lifetime: 'a.
    
@@ -21,43 +21,44 @@ property.
 
     Lifetime::new("'a", Span::call_site())
    
 
    pub fn span(&self) -> Span[src]
    pub fn set_span(&mut self, span: Span)[src]

    Trait Implementations

    impl Clone for Lifetime[src]

    impl Debug for Lifetime[src]

    impl Display for Lifetime[src]

    impl Eq for Lifetime[src]

    impl From<Lifetime> for TypeParamBound[src]

    impl Eq for Lifetime[src]

    impl From<Lifetime> for TypeParamBound[src]

    impl Hash for Lifetime[src]

    impl Ord for Lifetime[src]

    impl Parse for Lifetime[src]

    impl PartialEq<Lifetime> for Lifetime[src]

    impl PartialOrd<Lifetime> for Lifetime[src]

    impl ToTokens for Lifetime[src]

    impl Token for Lifetime[src]

    Auto Trait Implementations

    Blanket Implementations

    impl<T> Any for T where
        T: 'static + ?Sized,     [src]

    impl<T> Borrow<T> for T where
        T: ?Sized,     [src]

    impl<T> BorrowMut<T> for T where
        T: ?Sized,     [src]

    impl<T> From<T> for T[src]

    impl<T, U> Into<U> for T where
        U: From<T>,     [src]

    impl Token for Lifetime[src]

    Auto Trait Implementations

    impl RefUnwindSafe for Lifetime

    impl !Send for Lifetime

    impl !Sync for Lifetime

    impl Unpin for Lifetime

    impl UnwindSafe for Lifetime

    Blanket Implementations

    impl<T> Any for T where
        T: 'static + ?Sized,     [src]

    impl<T> Borrow<T> for T where
        T: ?Sized,     [src]

    impl<T> BorrowMut<T> for T where
        T: ?Sized,     [src]

    impl<T> From<T> for T[src]

    impl<T, U> Into<U> for T where
        U: From<T>,     [src]

    impl<T> Spanned for T where
        T: Spanned + ?Sized,     [src]

    impl<T> ToOwned for T where
        T: Clone,     [src]

    type Owned = T

    The resulting type after obtaining ownership.

    -

    impl<T> ToOwned for T where
        T: Clone,     [src]

    type Owned = T

    The resulting type after obtaining ownership.

    +

    impl<T> ToString for T where
        T: Display + ?Sized,     [src]

    impl<T, U> TryFrom<U> for T where
        U: Into<T>,     [src]

    type Error = Infallible

    The type returned in the event of a conversion error.

    -

    impl<T, U> TryInto<U> for T where
        U: TryFrom<T>,     [src]

    type Error = <U as TryFrom<T>>::Error

    The type returned in the event of a conversion error.

    -
    \ No newline at end of file +

    impl<T> ToString for T where
        T: Display + ?Sized,     [src]

    impl<T, U> TryFrom<U> for T where
        U: Into<T>,     [src]

    type Error = Infallible

    The type returned in the event of a conversion error.

    +

    impl<T, U> TryInto<U> for T where
        U: TryFrom<T>,     [src]

    type Error = <U as TryFrom<T>>::Error

    The type returned in the event of a conversion error.

    +
    + \ No newline at end of file diff --git a/syn/struct.LifetimeDef.html b/syn/struct.LifetimeDef.html index 2162a05..ae1d087 100644 --- a/syn/struct.LifetimeDef.html +++ b/syn/struct.LifetimeDef.html @@ -1,7 +1,7 @@ -syn::LifetimeDef - Rust +syn::LifetimeDef - Rust -

    [−][src]Struct syn::LifetimeDef

    pub struct LifetimeDef {
+
    Struct syn::LifetimeDef[−][src]
    pub struct LifetimeDef {
     pub attrs: Vec<Attribute>,
     pub lifetime: Lifetime,
     pub colon_token: Option<Colon>,
@@ -10,31 +10,32 @@
 
    This type is available only if Syn is built with the "derive" or
 "full" feature.
    
 
    
-                       Fields
    attrs: Vec<Attribute>lifetime: Lifetimecolon_token: Option<Colon>bounds: Punctuated<Lifetime, Add>
    Implementations
    impl LifetimeDef[src]
    pub fn new(lifetime: Lifetime) -> Self[src]
    Trait Implementations
    impl Clone for LifetimeDef[src]
    
\ No newline at end of file
+

    impl<T, U> TryFrom<U> for T where
        U: Into<T>,     [src]

    type Error = Infallible

    The type returned in the event of a conversion error.

    +

    impl<T, U> TryInto<U> for T where
        U: TryFrom<T>,     [src]

    type Error = <U as TryFrom<T>>::Error

    The type returned in the event of a conversion error.

    +
    + \ No newline at end of file diff --git a/syn/struct.LitBool.html b/syn/struct.LitBool.html index c71712d..b4dd6f9 100644 --- a/syn/struct.LitBool.html +++ b/syn/struct.LitBool.html @@ -1,36 +1,37 @@ -syn::LitBool - Rust +syn::LitBool - Rust -

    [−][src]Struct syn::LitBool

    pub struct LitBool {
+
    Struct syn::LitBool[−][src]
    pub struct LitBool {
     pub value: bool,
     pub span: Span,
 }
    A boolean literal: true or false.
    
 
    
                        Fields
    value: boolspan: Span
    Implementations
    impl LitBool[src]
    pub fn new(value: bool, span: Span) -> Self[src]
    pub fn value(&self) -> bool[src]
    pub fn span(&self) -> Span[src]
    pub fn set_span(&mut self, span: Span)[src]
    Trait Implementations
    impl Clone for LitBool[src]
    impl Debug for LitBool[src]
    impl Eq for LitBool[src]
    impl From<LitBool> for Lit[src]
    impl Hash for LitBool[src]
    impl Parse for LitBool[src]
    impl PartialEq<LitBool> for LitBool[src]
    impl ToTokens for LitBool[src]
    impl Token for LitBool[src]
    Auto Trait Implementations
    Blanket Implementations
    impl<T> Any for T where
        T: 'static + ?Sized,     [src]
    impl<T> Borrow<T> for T where
        T: ?Sized,     [src]
    impl<T> BorrowMut<T> for T where
        T: ?Sized,     [src]
    impl<T> From<T> for T[src]
    impl<T, U> Into<U> for T where
        U: From<T>,     [src]
    impl Token for LitBool[src]
    Auto Trait Implementations
    impl RefUnwindSafe for LitBool
    impl !Send for LitBool
    impl !Sync for LitBool
    impl Unpin for LitBool
    impl UnwindSafe for LitBool
    Blanket Implementations
    impl<T> Any for T where
        T: 'static + ?Sized,     [src]
    impl<T> Borrow<T> for T where
        T: ?Sized,     [src]
    impl<T> BorrowMut<T> for T where
        T: ?Sized,     [src]
    impl<T> From<T> for T[src]
    impl<T, U> Into<U> for T where
        U: From<T>,     [src]
    impl<T> Spanned for T where
        T: Spanned + ?Sized,     [src]
    impl<T> ToOwned for T where
        T: Clone,     [src]
    type Owned = T
    The resulting type after obtaining ownership.
    
-
    impl<T> ToOwned for T where
        T: Clone,     [src]
    type Owned = T
    The resulting type after obtaining ownership.
    
+
    impl<T, U> TryFrom<U> for T where
        U: Into<T>,     [src]
    type Error = Infallible
    The type returned in the event of a conversion error.
    
-
    impl<T, U> TryInto<U> for T where
        U: TryFrom<T>,     [src]
    type Error = <U as TryFrom<T>>::Error
    The type returned in the event of a conversion error.
    
-
    
\ No newline at end of file
+

    impl<T, U> TryFrom<U> for T where
        U: Into<T>,     [src]

    type Error = Infallible

    The type returned in the event of a conversion error.

    +

    impl<T, U> TryInto<U> for T where
        U: TryFrom<T>,     [src]

    type Error = <U as TryFrom<T>>::Error

    The type returned in the event of a conversion error.

    +
    + \ No newline at end of file diff --git a/syn/struct.LitByte.html b/syn/struct.LitByte.html index 95e9c8a..356babb 100644 --- a/syn/struct.LitByte.html +++ b/syn/struct.LitByte.html @@ -1,32 +1,33 @@ -syn::LitByte - Rust +syn::LitByte - Rust -

    [−][src]Struct syn::LitByte

    pub struct LitByte { /* fields omitted */ }

    A byte literal: b'f'.

    +

    Struct syn::LitByte[−][src]

    pub struct LitByte { /* fields omitted */ }

    A byte literal: b'f'.

    Implementations

    impl LitByte[src]

    pub fn new(value: u8, span: Span) -> Self[src]

    pub fn value(&self) -> u8[src]

    pub fn span(&self) -> Span[src]

    pub fn set_span(&mut self, span: Span)[src]

    pub fn suffix(&self) -> &str[src]

    Trait Implementations

    impl Clone for LitByte[src]

    impl Debug for LitByte[src]

    impl Eq for LitByte[src]

    impl From<LitByte> for Lit[src]

    impl Hash for LitByte[src]

    impl Parse for LitByte[src]

    impl PartialEq<LitByte> for LitByte[src]

    impl ToTokens for LitByte[src]

    impl Token for LitByte[src]

    Auto Trait Implementations

    Blanket Implementations

    impl<T> Any for T where
        T: 'static + ?Sized,     [src]

    impl<T> Borrow<T> for T where
        T: ?Sized,     [src]

    impl<T> BorrowMut<T> for T where
        T: ?Sized,     [src]

    impl<T> From<T> for T[src]

    impl<T, U> Into<U> for T where
        U: From<T>,     [src]

    impl Token for LitByte[src]

    Auto Trait Implementations

    impl RefUnwindSafe for LitByte

    impl !Send for LitByte

    impl !Sync for LitByte

    impl Unpin for LitByte

    impl UnwindSafe for LitByte

    Blanket Implementations

    impl<T> Any for T where
        T: 'static + ?Sized,     [src]

    impl<T> Borrow<T> for T where
        T: ?Sized,     [src]

    impl<T> BorrowMut<T> for T where
        T: ?Sized,     [src]

    impl<T> From<T> for T[src]

    impl<T, U> Into<U> for T where
        U: From<T>,     [src]

    impl<T> Spanned for T where
        T: Spanned + ?Sized,     [src]

    impl<T> ToOwned for T where
        T: Clone,     [src]

    type Owned = T

    The resulting type after obtaining ownership.

    -

    impl<T> ToOwned for T where
        T: Clone,     [src]

    type Owned = T

    The resulting type after obtaining ownership.

    +

    impl<T, U> TryFrom<U> for T where
        U: Into<T>,     [src]

    type Error = Infallible

    The type returned in the event of a conversion error.

    -

    impl<T, U> TryInto<U> for T where
        U: TryFrom<T>,     [src]

    type Error = <U as TryFrom<T>>::Error

    The type returned in the event of a conversion error.

    -
    \ No newline at end of file +

    impl<T, U> TryFrom<U> for T where
        U: Into<T>,     [src]

    type Error = Infallible

    The type returned in the event of a conversion error.

    +

    impl<T, U> TryInto<U> for T where
        U: TryFrom<T>,     [src]

    type Error = <U as TryFrom<T>>::Error

    The type returned in the event of a conversion error.

    +
    + \ No newline at end of file diff --git a/syn/struct.LitByteStr.html b/syn/struct.LitByteStr.html index d056cc1..1ac2de2 100644 --- a/syn/struct.LitByteStr.html +++ b/syn/struct.LitByteStr.html @@ -1,32 +1,33 @@ -syn::LitByteStr - Rust +syn::LitByteStr - Rust -

    [−][src]Struct syn::LitByteStr

    pub struct LitByteStr { /* fields omitted */ }

    A byte string literal: b"foo".

    +

    Struct syn::LitByteStr[−][src]

    pub struct LitByteStr { /* fields omitted */ }

    A byte string literal: b"foo".

    Implementations

    impl LitByteStr[src]

    pub fn new(value: &[u8], span: Span) -> Self[src]

    pub fn value(&self) -> Vec<u8>[src]

    pub fn span(&self) -> Span[src]

    pub fn set_span(&mut self, span: Span)[src]

    pub fn suffix(&self) -> &str[src]

    Trait Implementations

    impl Clone for LitByteStr[src]

    impl Debug for LitByteStr[src]

    impl Eq for LitByteStr[src]

    impl From<LitByteStr> for Lit[src]

    impl Hash for LitByteStr[src]

    impl Parse for LitByteStr[src]

    impl PartialEq<LitByteStr> for LitByteStr[src]

    impl ToTokens for LitByteStr[src]

    impl Token for LitByteStr[src]

    Auto Trait Implementations

    Blanket Implementations

    impl<T> Any for T where
        T: 'static + ?Sized,     [src]

    impl<T> Borrow<T> for T where
        T: ?Sized,     [src]

    impl<T> BorrowMut<T> for T where
        T: ?Sized,     [src]

    impl<T> From<T> for T[src]

    impl<T, U> Into<U> for T where
        U: From<T>,     [src]

    impl Token for LitByteStr[src]

    Auto Trait Implementations

    Blanket Implementations

    impl<T> Any for T where
        T: 'static + ?Sized,     [src]

    impl<T> Borrow<T> for T where
        T: ?Sized,     [src]

    impl<T> BorrowMut<T> for T where
        T: ?Sized,     [src]

    impl<T> From<T> for T[src]

    impl<T, U> Into<U> for T where
        U: From<T>,     [src]

    impl<T> Spanned for T where
        T: Spanned + ?Sized,     [src]

    impl<T> ToOwned for T where
        T: Clone,     [src]

    type Owned = T

    The resulting type after obtaining ownership.

    -

    impl<T> ToOwned for T where
        T: Clone,     [src]

    type Owned = T

    The resulting type after obtaining ownership.

    +

    impl<T, U> TryFrom<U> for T where
        U: Into<T>,     [src]

    type Error = Infallible

    The type returned in the event of a conversion error.

    -

    impl<T, U> TryInto<U> for T where
        U: TryFrom<T>,     [src]

    type Error = <U as TryFrom<T>>::Error

    The type returned in the event of a conversion error.

    -
    \ No newline at end of file +

    impl<T, U> TryFrom<U> for T where
        U: Into<T>,     [src]

    type Error = Infallible

    The type returned in the event of a conversion error.

    +

    impl<T, U> TryInto<U> for T where
        U: TryFrom<T>,     [src]

    type Error = <U as TryFrom<T>>::Error

    The type returned in the event of a conversion error.

    +
    + \ No newline at end of file diff --git a/syn/struct.LitChar.html b/syn/struct.LitChar.html index 1233ddf..fd9498a 100644 --- a/syn/struct.LitChar.html +++ b/syn/struct.LitChar.html @@ -1,32 +1,33 @@ -syn::LitChar - Rust +syn::LitChar - Rust -

    [−][src]Struct syn::LitChar

    pub struct LitChar { /* fields omitted */ }

    A character literal: 'a'.

    +

    Struct syn::LitChar[−][src]

    pub struct LitChar { /* fields omitted */ }

    A character literal: 'a'.

    Implementations

    impl LitChar[src]

    pub fn new(value: char, span: Span) -> Self[src]

    pub fn value(&self) -> char[src]

    pub fn span(&self) -> Span[src]

    pub fn set_span(&mut self, span: Span)[src]

    pub fn suffix(&self) -> &str[src]

    Trait Implementations

    impl Clone for LitChar[src]

    impl Debug for LitChar[src]

    impl Eq for LitChar[src]

    impl From<LitChar> for Lit[src]

    impl Hash for LitChar[src]

    impl Parse for LitChar[src]

    impl PartialEq<LitChar> for LitChar[src]

    impl ToTokens for LitChar[src]

    impl Token for LitChar[src]

    Auto Trait Implementations

    Blanket Implementations

    impl<T> Any for T where
        T: 'static + ?Sized,     [src]

    impl<T> Borrow<T> for T where
        T: ?Sized,     [src]

    impl<T> BorrowMut<T> for T where
        T: ?Sized,     [src]

    impl<T> From<T> for T[src]

    impl<T, U> Into<U> for T where
        U: From<T>,     [src]

    impl Token for LitChar[src]

    Auto Trait Implementations

    impl RefUnwindSafe for LitChar

    impl !Send for LitChar

    impl !Sync for LitChar

    impl Unpin for LitChar

    impl UnwindSafe for LitChar

    Blanket Implementations

    impl<T> Any for T where
        T: 'static + ?Sized,     [src]

    impl<T> Borrow<T> for T where
        T: ?Sized,     [src]

    impl<T> BorrowMut<T> for T where
        T: ?Sized,     [src]

    impl<T> From<T> for T[src]

    impl<T, U> Into<U> for T where
        U: From<T>,     [src]

    impl<T> Spanned for T where
        T: Spanned + ?Sized,     [src]

    impl<T> ToOwned for T where
        T: Clone,     [src]

    type Owned = T

    The resulting type after obtaining ownership.

    -

    impl<T> ToOwned for T where
        T: Clone,     [src]

    type Owned = T

    The resulting type after obtaining ownership.

    +

    impl<T, U> TryFrom<U> for T where
        U: Into<T>,     [src]

    type Error = Infallible

    The type returned in the event of a conversion error.

    -

    impl<T, U> TryInto<U> for T where
        U: TryFrom<T>,     [src]

    type Error = <U as TryFrom<T>>::Error

    The type returned in the event of a conversion error.

    -
    \ No newline at end of file +

    impl<T, U> TryFrom<U> for T where
        U: Into<T>,     [src]

    type Error = Infallible

    The type returned in the event of a conversion error.

    +

    impl<T, U> TryInto<U> for T where
        U: TryFrom<T>,     [src]

    type Error = <U as TryFrom<T>>::Error

    The type returned in the event of a conversion error.

    +
    + \ No newline at end of file diff --git a/syn/struct.LitFloat.html b/syn/struct.LitFloat.html index 7255ad2..ad54a4e 100644 --- a/syn/struct.LitFloat.html +++ b/syn/struct.LitFloat.html @@ -1,36 +1,37 @@ -syn::LitFloat - Rust +syn::LitFloat - Rust -

    [−][src]Struct syn::LitFloat

    pub struct LitFloat { /* fields omitted */ }

    A floating point literal: 1f64 or 1.0e10f64.

    +

    Struct syn::LitFloat[−][src]

    pub struct LitFloat { /* fields omitted */ }

    A floating point literal: 1f64 or 1.0e10f64.

    Must be finite. May not be infinite or NaN.

    Implementations

    impl LitFloat[src]

    pub fn new(repr: &str, span: Span) -> Self[src]

    pub fn base10_digits(&self) -> &str[src]

    pub fn base10_parse<N>(&self) -> Result<N> where
        N: FromStr,
        N::Err: Display,     [src]

    pub fn suffix(&self) -> &str[src]

    pub fn span(&self) -> Span[src]

    pub fn set_span(&mut self, span: Span)[src]

    Trait Implementations

    impl Clone for LitFloat[src]

    impl Debug for LitFloat[src]

    impl Display for LitFloat[src]

    impl Eq for LitFloat[src]

    impl From<LitFloat> for Lit[src]

    impl From<Literal> for LitFloat[src]

    impl Hash for LitFloat[src]

    impl Parse for LitFloat[src]

    impl PartialEq<LitFloat> for LitFloat[src]

    impl ToTokens for LitFloat[src]

    impl Token for LitFloat[src]

    Auto Trait Implementations

    Blanket Implementations

    impl<T> Any for T where
        T: 'static + ?Sized,     [src]

    impl<T> Borrow<T> for T where
        T: ?Sized,     [src]

    impl<T> BorrowMut<T> for T where
        T: ?Sized,     [src]

    impl<T> From<T> for T[src]

    impl<T, U> Into<U> for T where
        U: From<T>,     [src]

    impl Token for LitFloat[src]

    Auto Trait Implementations

    impl RefUnwindSafe for LitFloat

    impl !Send for LitFloat

    impl !Sync for LitFloat

    impl Unpin for LitFloat

    impl UnwindSafe for LitFloat

    Blanket Implementations

    impl<T> Any for T where
        T: 'static + ?Sized,     [src]

    impl<T> Borrow<T> for T where
        T: ?Sized,     [src]

    impl<T> BorrowMut<T> for T where
        T: ?Sized,     [src]

    impl<T> From<T> for T[src]

    impl<T, U> Into<U> for T where
        U: From<T>,     [src]

    impl<T> Spanned for T where
        T: Spanned + ?Sized,     [src]

    impl<T> ToOwned for T where
        T: Clone,     [src]

    type Owned = T

    The resulting type after obtaining ownership.

    -

    impl<T> ToOwned for T where
        T: Clone,     [src]

    type Owned = T

    The resulting type after obtaining ownership.

    +

    impl<T> ToString for T where
        T: Display + ?Sized,     [src]

    impl<T, U> TryFrom<U> for T where
        U: Into<T>,     [src]

    type Error = Infallible

    The type returned in the event of a conversion error.

    -

    impl<T, U> TryInto<U> for T where
        U: TryFrom<T>,     [src]

    type Error = <U as TryFrom<T>>::Error

    The type returned in the event of a conversion error.

    -
    \ No newline at end of file +

    impl<T> ToString for T where
        T: Display + ?Sized,     [src]

    impl<T, U> TryFrom<U> for T where
        U: Into<T>,     [src]

    type Error = Infallible

    The type returned in the event of a conversion error.

    +

    impl<T, U> TryInto<U> for T where
        U: TryFrom<T>,     [src]

    type Error = <U as TryFrom<T>>::Error

    The type returned in the event of a conversion error.

    +
    + \ No newline at end of file diff --git a/syn/struct.LitInt.html b/syn/struct.LitInt.html index 3665057..32bf4ac 100644 --- a/syn/struct.LitInt.html +++ b/syn/struct.LitInt.html @@ -1,7 +1,7 @@ -syn::LitInt - Rust +syn::LitInt - Rust -

    [−][src]Struct syn::LitInt

    pub struct LitInt { /* fields omitted */ }

    An integer literal: 1 or 1u16.

    +

    Struct syn::LitInt[−][src]

    pub struct LitInt { /* fields omitted */ }

    An integer literal: 1 or 1u16.

    Implementations

    impl LitInt[src]

    pub fn new(repr: &str, span: Span) -> Self[src]

    pub fn base10_digits(&self) -> &str[src]

    pub fn base10_parse<N>(&self) -> Result<N> where
        N: FromStr,
        N::Err: Display,     [src]

    Parses the literal into a selected number type.

    This is equivalent to lit.base10_digits().parse() except that the resulting errors will be correctly spanned to point to the literal token @@ -23,33 +23,34 @@ in the macro input.

    } }

    pub fn suffix(&self) -> &str[src]

    pub fn span(&self) -> Span[src]

    pub fn set_span(&mut self, span: Span)[src]

    Trait Implementations

    impl Clone for LitInt[src]

    impl Debug for LitInt[src]

    impl Display for LitInt[src]

    impl Eq for LitInt[src]

    impl From<LitInt> for Lit[src]

    impl From<Literal> for LitInt[src]

    impl Hash for LitInt[src]

    impl Parse for LitInt[src]

    impl PartialEq<LitInt> for LitInt[src]

    impl ToTokens for LitInt[src]

    impl Token for LitInt[src]

    Auto Trait Implementations

    Blanket Implementations

    impl<T> Any for T where
        T: 'static + ?Sized,     [src]

    impl<T> Borrow<T> for T where
        T: ?Sized,     [src]

    impl<T> BorrowMut<T> for T where
        T: ?Sized,     [src]

    impl<T> From<T> for T[src]

    impl<T, U> Into<U> for T where
        U: From<T>,     [src]

    impl Token for LitInt[src]

    Auto Trait Implementations

    impl RefUnwindSafe for LitInt

    impl !Send for LitInt

    impl !Sync for LitInt

    impl Unpin for LitInt

    impl UnwindSafe for LitInt

    Blanket Implementations

    impl<T> Any for T where
        T: 'static + ?Sized,     [src]

    impl<T> Borrow<T> for T where
        T: ?Sized,     [src]

    impl<T> BorrowMut<T> for T where
        T: ?Sized,     [src]

    impl<T> From<T> for T[src]

    impl<T, U> Into<U> for T where
        U: From<T>,     [src]

    impl<T> Spanned for T where
        T: Spanned + ?Sized,     [src]

    impl<T> ToOwned for T where
        T: Clone,     [src]

    type Owned = T

    The resulting type after obtaining ownership.

    -

    impl<T> ToOwned for T where
        T: Clone,     [src]

    type Owned = T

    The resulting type after obtaining ownership.

    +

    impl<T> ToString for T where
        T: Display + ?Sized,     [src]

    impl<T, U> TryFrom<U> for T where
        U: Into<T>,     [src]

    type Error = Infallible

    The type returned in the event of a conversion error.

    -

    impl<T, U> TryInto<U> for T where
        U: TryFrom<T>,     [src]

    type Error = <U as TryFrom<T>>::Error

    The type returned in the event of a conversion error.

    -
    \ No newline at end of file +

    impl<T> ToString for T where
        T: Display + ?Sized,     [src]

    impl<T, U> TryFrom<U> for T where
        U: Into<T>,     [src]

    type Error = Infallible

    The type returned in the event of a conversion error.

    +

    impl<T, U> TryInto<U> for T where
        U: TryFrom<T>,     [src]

    type Error = <U as TryFrom<T>>::Error

    The type returned in the event of a conversion error.

    +
    + \ No newline at end of file diff --git a/syn/struct.LitStr.html b/syn/struct.LitStr.html index c67dc18..ca7547f 100644 --- a/syn/struct.LitStr.html +++ b/syn/struct.LitStr.html @@ -1,7 +1,7 @@ -syn::LitStr - Rust +syn::LitStr - Rust -

    [−][src]Struct syn::LitStr

    pub struct LitStr { /* fields omitted */ }

    A UTF-8 string literal: "foo".

    +

    Struct syn::LitStr[−][src]

    pub struct LitStr { /* fields omitted */ }

    A UTF-8 string literal: "foo".

    Implementations

    impl LitStr[src]

    pub fn new(value: &str, span: Span) -> Self[src]

    pub fn value(&self) -> String[src]

    pub fn parse<T: Parse>(&self) -> Result<T>[src]

    Parse a syntax tree node from the content of this string literal.

    All spans in the syntax tree will point to the span of this LitStr.

    Example

    @@ -39,30 +39,31 @@ // generic arguments on any of the path segments. let basic_path = lit_str.parse_with(syn::Path::parse_mod_style)?;

    pub fn span(&self) -> Span[src]

    pub fn set_span(&mut self, span: Span)[src]

    pub fn suffix(&self) -> &str[src]

    Trait Implementations

    impl Clone for LitStr[src]

    impl Debug for LitStr[src]

    impl Eq for LitStr[src]

    impl From<LitStr> for Lit[src]

    impl Hash for LitStr[src]

    impl Parse for LitStr[src]

    impl PartialEq<LitStr> for LitStr[src]

    impl ToTokens for LitStr[src]

    impl Token for LitStr[src]

    Auto Trait Implementations

    Blanket Implementations

    impl<T> Any for T where
        T: 'static + ?Sized,     [src]

    impl<T> Borrow<T> for T where
        T: ?Sized,     [src]

    impl<T> BorrowMut<T> for T where
        T: ?Sized,     [src]

    impl<T> From<T> for T[src]

    impl<T, U> Into<U> for T where
        U: From<T>,     [src]

    impl Token for LitStr[src]

    Auto Trait Implementations

    impl RefUnwindSafe for LitStr

    impl !Send for LitStr

    impl !Sync for LitStr

    impl Unpin for LitStr

    impl UnwindSafe for LitStr

    Blanket Implementations

    impl<T> Any for T where
        T: 'static + ?Sized,     [src]

    impl<T> Borrow<T> for T where
        T: ?Sized,     [src]

    impl<T> BorrowMut<T> for T where
        T: ?Sized,     [src]

    impl<T> From<T> for T[src]

    impl<T, U> Into<U> for T where
        U: From<T>,     [src]

    impl<T> Spanned for T where
        T: Spanned + ?Sized,     [src]

    impl<T> ToOwned for T where
        T: Clone,     [src]

    type Owned = T

    The resulting type after obtaining ownership.

    -

    impl<T> ToOwned for T where
        T: Clone,     [src]

    type Owned = T

    The resulting type after obtaining ownership.

    +

    impl<T, U> TryFrom<U> for T where
        U: Into<T>,     [src]

    type Error = Infallible

    The type returned in the event of a conversion error.

    -

    impl<T, U> TryInto<U> for T where
        U: TryFrom<T>,     [src]

    type Error = <U as TryFrom<T>>::Error

    The type returned in the event of a conversion error.

    -
    \ No newline at end of file +

    impl<T, U> TryFrom<U> for T where
        U: Into<T>,     [src]

    type Error = Infallible

    The type returned in the event of a conversion error.

    +

    impl<T, U> TryInto<U> for T where
        U: TryFrom<T>,     [src]

    type Error = <U as TryFrom<T>>::Error

    The type returned in the event of a conversion error.

    +
    + \ No newline at end of file diff --git a/syn/struct.Macro.html b/syn/struct.Macro.html index 919da3a..5495a71 100644 --- a/syn/struct.Macro.html +++ b/syn/struct.Macro.html @@ -1,7 +1,7 @@ -syn::Macro - Rust +syn::Macro - Rust -

    [−][src]Struct syn::Macro

    pub struct Macro {
+
    Struct syn::Macro[−][src]
    pub struct Macro {
     pub path: Path,
     pub bang_token: Bang,
     pub delimiter: MacroDelimiter,
@@ -10,7 +10,7 @@
 
    This type is available only if Syn is built with the "derive" or "full"
 feature.
    
 
    
-                       Fields
    path: Pathbang_token: Bangdelimiter: MacroDelimitertokens: TokenStream
    Implementations
    impl Macro[src]
    pub fn parse_body<T: Parse>(&self) -> Result<T>[src]
    Parse the tokens within the macro invocation's delimiters into a syntax
+                       Fieldspath: Pathbang_token: Bangdelimiter: MacroDelimitertokens: TokenStream
    Implementations
    impl Macro[src]
    pub fn parse_body<T: Parse>(&self) -> Result<T>[src]
    Parse the tokens within the macro invocation’s delimiters into a syntax
 tree.
    
 
    This is equivalent to syn::parse2::<T>(mac.tokens) except that it
 produces a more useful span when tokens is empty.
    
@@ -88,32 +88,33 @@ produces a more useful span when tokens is empty.
    
     let lit = get_format_string(&invocation).unwrap();
     assert_eq!(lit.value(), "{:?}");
 }
    -

    pub fn parse_body_with<F: Parser>(&self, parser: F) -> Result<F::Output>[src]

    Parse the tokens within the macro invocation's delimiters using the +

    pub fn parse_body_with<F: Parser>(&self, parser: F) -> Result<F::Output>[src]

    Parse the tokens within the macro invocation’s delimiters using the given parser.

    Trait Implementations

    impl Clone for Macro[src]

    impl Debug for Macro[src]

    impl Eq for Macro[src]

    impl Hash for Macro[src]

    impl Parse for Macro[src]

    impl PartialEq<Macro> for Macro[src]

    impl ToTokens for Macro[src]

    Auto Trait Implementations

    Blanket Implementations

    impl<T> Any for T where
        T: 'static + ?Sized,     [src]

    impl<T> Borrow<T> for T where
        T: ?Sized,     [src]

    impl<T> BorrowMut<T> for T where
        T: ?Sized,     [src]

    impl<T> From<T> for T[src]

    impl<T, U> Into<U> for T where
        U: From<T>,     [src]

    Auto Trait Implementations

    impl RefUnwindSafe for Macro

    impl !Send for Macro

    impl !Sync for Macro

    impl Unpin for Macro

    impl UnwindSafe for Macro

    Blanket Implementations

    impl<T> Any for T where
        T: 'static + ?Sized,     [src]

    impl<T> Borrow<T> for T where
        T: ?Sized,     [src]

    impl<T> BorrowMut<T> for T where
        T: ?Sized,     [src]

    impl<T> From<T> for T[src]

    impl<T, U> Into<U> for T where
        U: From<T>,     [src]

    impl<T> Spanned for T where
        T: Spanned + ?Sized,     [src]

    impl<T> ToOwned for T where
        T: Clone,     [src]

    type Owned = T

    The resulting type after obtaining ownership.

    -

    impl<T> ToOwned for T where
        T: Clone,     [src]

    type Owned = T

    The resulting type after obtaining ownership.

    +

    impl<T, U> TryFrom<U> for T where
        U: Into<T>,     [src]

    type Error = Infallible

    The type returned in the event of a conversion error.

    -

    impl<T, U> TryInto<U> for T where
        U: TryFrom<T>,     [src]

    type Error = <U as TryFrom<T>>::Error

    The type returned in the event of a conversion error.

    -
    \ No newline at end of file +

    impl<T, U> TryFrom<U> for T where
        U: Into<T>,     [src]

    type Error = Infallible

    The type returned in the event of a conversion error.

    +

    impl<T, U> TryInto<U> for T where
        U: TryFrom<T>,     [src]

    type Error = <U as TryFrom<T>>::Error

    The type returned in the event of a conversion error.

    +
    + \ No newline at end of file diff --git a/syn/struct.MetaList.html b/syn/struct.MetaList.html index d33808d..99e051c 100644 --- a/syn/struct.MetaList.html +++ b/syn/struct.MetaList.html @@ -1,7 +1,7 @@ -syn::MetaList - Rust +syn::MetaList - Rust -

    [−][src]Struct syn::MetaList

    pub struct MetaList {
+
    Struct syn::MetaList[−][src]
    pub struct MetaList {
     pub path: Path,
     pub paren_token: Paren,
     pub nested: Punctuated<NestedMeta, Comma>,
@@ -10,30 +10,31 @@
 "full" feature.
    
 
    
                        Fields
    path: Pathparen_token: Parennested: Punctuated<NestedMeta, Comma>
    Trait Implementations
    impl Clone for MetaList[src]
    impl Debug for MetaList[src]
    impl Eq for MetaList[src]
    impl From<MetaList> for Meta[src]
    impl Eq for MetaList[src]
    impl From<MetaList> for Meta[src]
    impl Hash for MetaList[src]
    impl Parse for MetaList[src]
    impl PartialEq<MetaList> for MetaList[src]
    impl Parse for MetaList[src]
    impl PartialEq<MetaList> for MetaList[src]
    impl ToTokens for MetaList[src]
    Auto Trait Implementations
    Blanket Implementations
    impl<T> Any for T where
        T: 'static + ?Sized,     [src]
    impl<T> Borrow<T> for T where
        T: ?Sized,     [src]
    impl<T> BorrowMut<T> for T where
        T: ?Sized,     [src]
    impl<T> From<T> for T[src]
    impl<T, U> Into<U> for T where
        U: From<T>,     [src]
    impl ToTokens for MetaList[src]
    Auto Trait Implementations
    impl RefUnwindSafe for MetaList
    impl !Send for MetaList
    impl !Sync for MetaList
    impl Unpin for MetaList
    impl UnwindSafe for MetaList
    Blanket Implementations
    impl<T> Any for T where
        T: 'static + ?Sized,     [src]
    impl<T> Borrow<T> for T where
        T: ?Sized,     [src]
    impl<T> BorrowMut<T> for T where
        T: ?Sized,     [src]
    impl<T> From<T> for T[src]
    impl<T, U> Into<U> for T where
        U: From<T>,     [src]
    impl<T> Spanned for T where
        T: Spanned + ?Sized,     [src]
    impl<T> ToOwned for T where
        T: Clone,     [src]
    type Owned = T
    The resulting type after obtaining ownership.
    
-
    impl<T> ToOwned for T where
        T: Clone,     [src]
    type Owned = T
    The resulting type after obtaining ownership.
    
+
    impl<T, U> TryFrom<U> for T where
        U: Into<T>,     [src]
    type Error = Infallible
    The type returned in the event of a conversion error.
    
-
    impl<T, U> TryInto<U> for T where
        U: TryFrom<T>,     [src]
    type Error = <U as TryFrom<T>>::Error
    The type returned in the event of a conversion error.
    
-
    
\ No newline at end of file
+

    impl<T, U> TryFrom<U> for T where
        U: Into<T>,     [src]

    type Error = Infallible

    The type returned in the event of a conversion error.

    +

    impl<T, U> TryInto<U> for T where
        U: TryFrom<T>,     [src]

    type Error = <U as TryFrom<T>>::Error

    The type returned in the event of a conversion error.

    +
    + \ No newline at end of file diff --git a/syn/struct.MetaNameValue.html b/syn/struct.MetaNameValue.html index 55c8e98..8367555 100644 --- a/syn/struct.MetaNameValue.html +++ b/syn/struct.MetaNameValue.html @@ -1,7 +1,7 @@ -syn::MetaNameValue - Rust +syn::MetaNameValue - Rust -

    [−][src]Struct syn::MetaNameValue

    pub struct MetaNameValue {
+
    Struct syn::MetaNameValue[−][src]
    pub struct MetaNameValue {
     pub path: Path,
     pub eq_token: Eq,
     pub lit: Lit,
@@ -10,30 +10,31 @@
 "full" feature.
    
 
    
                        Fields
    path: Patheq_token: Eqlit: Lit
    Trait Implementations
    impl Clone for MetaNameValue[src]
    impl Debug for MetaNameValue[src]
    impl Eq for MetaNameValue[src]
    impl From<MetaNameValue> for Meta[src]
    impl Eq for MetaNameValue[src]
    impl From<MetaNameValue> for Meta[src]
    impl Hash for MetaNameValue[src]
    impl Parse for MetaNameValue[src]
    impl PartialEq<MetaNameValue> for MetaNameValue[src]
    impl Parse for MetaNameValue[src]
    impl PartialEq<MetaNameValue> for MetaNameValue[src]
    impl ToTokens for MetaNameValue[src]
    Auto Trait Implementations
    Blanket Implementations
    impl<T> Any for T where
        T: 'static + ?Sized,     [src]
    impl<T> Borrow<T> for T where
        T: ?Sized,     [src]
    impl<T> BorrowMut<T> for T where
        T: ?Sized,     [src]
    impl<T> From<T> for T[src]
    impl<T, U> Into<U> for T where
        U: From<T>,     [src]
    impl ToTokens for MetaNameValue[src]
    Auto Trait Implementations
    Blanket Implementations
    impl<T> Any for T where
        T: 'static + ?Sized,     [src]
    impl<T> Borrow<T> for T where
        T: ?Sized,     [src]
    impl<T> BorrowMut<T> for T where
        T: ?Sized,     [src]
    impl<T> From<T> for T[src]
    impl<T, U> Into<U> for T where
        U: From<T>,     [src]
    impl<T> Spanned for T where
        T: Spanned + ?Sized,     [src]
    impl<T> ToOwned for T where
        T: Clone,     [src]
    type Owned = T
    The resulting type after obtaining ownership.
    
-
    impl<T> ToOwned for T where
        T: Clone,     [src]
    type Owned = T
    The resulting type after obtaining ownership.
    
+
    impl<T, U> TryFrom<U> for T where
        U: Into<T>,     [src]
    type Error = Infallible
    The type returned in the event of a conversion error.
    
-
    impl<T, U> TryInto<U> for T where
        U: TryFrom<T>,     [src]
    type Error = <U as TryFrom<T>>::Error
    The type returned in the event of a conversion error.
    
-
    
\ No newline at end of file
+

    impl<T, U> TryFrom<U> for T where
        U: Into<T>,     [src]

    type Error = Infallible

    The type returned in the event of a conversion error.

    +

    impl<T, U> TryInto<U> for T where
        U: TryFrom<T>,     [src]

    type Error = <U as TryFrom<T>>::Error

    The type returned in the event of a conversion error.

    +
    + \ No newline at end of file diff --git a/syn/struct.ParenthesizedGenericArguments.html b/syn/struct.ParenthesizedGenericArguments.html index f71a7ec..a470c0c 100644 --- a/syn/struct.ParenthesizedGenericArguments.html +++ b/syn/struct.ParenthesizedGenericArguments.html @@ -1,7 +1,7 @@ -syn::ParenthesizedGenericArguments - Rust +syn::ParenthesizedGenericArguments - Rust -

    [−][src]Struct syn::ParenthesizedGenericArguments

    pub struct ParenthesizedGenericArguments {
+
    Struct syn::ParenthesizedGenericArguments[−][src]
    pub struct ParenthesizedGenericArguments {
     pub paren_token: Paren,
     pub inputs: Punctuated<Type, Comma>,
     pub output: ReturnType,
@@ -12,29 +12,30 @@ feature.
    
                        Fieldsparen_token: Pareninputs: Punctuated<Type, Comma>
    (A, B)
    
 
    output: ReturnType
    C
    
 
    Trait Implementations
    impl Clone for ParenthesizedGenericArguments[src]
    impl Debug for ParenthesizedGenericArguments[src]
    impl Eq for ParenthesizedGenericArguments[src]
    impl Hash for ParenthesizedGenericArguments[src]
    impl Parse for ParenthesizedGenericArguments[src]
    impl PartialEq<ParenthesizedGenericArguments> for ParenthesizedGenericArguments[src]
    impl Parse for ParenthesizedGenericArguments[src]
    impl PartialEq<ParenthesizedGenericArguments> for ParenthesizedGenericArguments[src]
    impl ToTokens for ParenthesizedGenericArguments[src]
    Auto Trait Implementations
    Blanket Implementations
    impl<T> Any for T where
        T: 'static + ?Sized,     [src]
    impl<T> Borrow<T> for T where
        T: ?Sized,     [src]
    impl<T> BorrowMut<T> for T where
        T: ?Sized,     [src]
    impl<T> From<T> for T[src]
    impl<T, U> Into<U> for T where
        U: From<T>,     [src]
    impl ToTokens for ParenthesizedGenericArguments[src]
    Auto Trait Implementations
    Blanket Implementations
    impl<T> Any for T where
        T: 'static + ?Sized,     [src]
    impl<T> Borrow<T> for T where
        T: ?Sized,     [src]
    impl<T> BorrowMut<T> for T where
        T: ?Sized,     [src]
    impl<T> From<T> for T[src]
    impl<T, U> Into<U> for T where
        U: From<T>,     [src]
    impl<T> Spanned for T where
        T: Spanned + ?Sized,     [src]
    impl<T> ToOwned for T where
        T: Clone,     [src]
    type Owned = T
    The resulting type after obtaining ownership.
    
-
    impl<T> ToOwned for T where
        T: Clone,     [src]
    type Owned = T
    The resulting type after obtaining ownership.
    
+
    impl<T, U> TryFrom<U> for T where
        U: Into<T>,     [src]
    type Error = Infallible
    The type returned in the event of a conversion error.
    
-
    impl<T, U> TryInto<U> for T where
        U: TryFrom<T>,     [src]
    type Error = <U as TryFrom<T>>::Error
    The type returned in the event of a conversion error.
    
-
    
\ No newline at end of file
+

    impl<T, U> TryFrom<U> for T where
        U: Into<T>,     [src]

    type Error = Infallible

    The type returned in the event of a conversion error.

    +

    impl<T, U> TryInto<U> for T where
        U: TryFrom<T>,     [src]

    type Error = <U as TryFrom<T>>::Error

    The type returned in the event of a conversion error.

    +
    + \ No newline at end of file diff --git a/syn/struct.Path.html b/syn/struct.Path.html index 5fc6f31..2b5607f 100644 --- a/syn/struct.Path.html +++ b/syn/struct.Path.html @@ -1,14 +1,14 @@ -syn::Path - Rust +syn::Path - Rust -

    [−][src]Struct syn::Path

    pub struct Path {
+
    Struct syn::Path[−][src]
    pub struct Path {
     pub leading_colon: Option<Colon2>,
     pub segments: Punctuated<PathSegment, Colon2>,
 }
    A path at which a named item is exported (e.g. std::collections::HashMap).
    
 
    This type is available only if Syn is built with the "derive" or "full"
 feature.
    
 
    
-                       Fields
    leading_colon: Option<Colon2>segments: Punctuated<PathSegment, Colon2>
    Implementations
    impl Path[src]
    pub fn parse_mod_style(input: ParseStream<'_>) -> Result<Self>[src]
    Parse a Path containing no path arguments on any of its segments.
    
+                       Fieldsleading_colon: Option<Colon2>segments: Punctuated<PathSegment, Colon2>
    Implementations
    impl Path[src]
    pub fn parse_mod_style(input: ParseStream<'_>) -> Result<Self>[src]
    Parse a Path containing no path arguments on any of its segments.
    
 
    This function is available only if Syn is built with the "parsing"
 feature.
    
 
    Example
    
@@ -37,7 +37,7 @@ feature.
    
         })
     }
 }
    -

    pub fn is_ident<I: ?Sized>(&self, ident: &I) -> bool where
        Ident: PartialEq<I>,     [src]

    Determines whether this is a path of length 1 equal to the given +

    pub fn is_ident<I: ?Sized>(&self, ident: &I) -> bool where
        Ident: PartialEq<I>,     [src]

    Determines whether this is a path of length 1 equal to the given ident.

    For them to compare equal, it must be the case that:

      @@ -63,7 +63,7 @@ feature.

      Ok(Vec::new()) } }
    -

    pub fn get_ident(&self) -> Option<&Ident>[src]

    If this path consists of a single ident, returns the ident.

    +

    pub fn get_ident(&self) -> Option<&Ident>[src]

    If this path consists of a single ident, returns the ident.

    A path is considered an ident if:

    • the path has no leading colon,
      • @@ -74,31 +74,32 @@ path arguments.

      This function is available only if Syn is built with the "parsing" feature.

    Trait Implementations

    impl Clone for Path[src]

    impl Debug for Path[src]

    impl Eq for Path[src]

    impl From<Path> for Meta[src]

    impl Eq for Path[src]

    impl From<Path> for Meta[src]

    impl<T> From<T> for Path where
        T: Into<PathSegment>,     [src]

    impl Hash for Path[src]

    impl Parse for Path[src]

    impl PartialEq<Path> for Path[src]

    impl Parse for Path[src]

    impl PartialEq<Path> for Path[src]

    impl ToTokens for Path[src]

    Auto Trait Implementations

    Blanket Implementations

    impl<T> Any for T where
        T: 'static + ?Sized,     [src]

    impl<T> Borrow<T> for T where
        T: ?Sized,     [src]

    impl<T> BorrowMut<T> for T where
        T: ?Sized,     [src]

    impl<T> From<T> for T[src]

    impl<T, U> Into<U> for T where
        U: From<T>,     [src]

    impl ToTokens for Path[src]

    Auto Trait Implementations

    impl RefUnwindSafe for Path

    impl !Send for Path

    impl !Sync for Path

    impl Unpin for Path

    impl UnwindSafe for Path

    Blanket Implementations

    impl<T> Any for T where
        T: 'static + ?Sized,     [src]

    impl<T> Borrow<T> for T where
        T: ?Sized,     [src]

    impl<T> BorrowMut<T> for T where
        T: ?Sized,     [src]

    impl<T> From<T> for T[src]

    impl<T, U> Into<U> for T where
        U: From<T>,     [src]

    impl<T> Spanned for T where
        T: Spanned + ?Sized,     [src]

    impl<T> ToOwned for T where
        T: Clone,     [src]

    type Owned = T

    The resulting type after obtaining ownership.

    -

    impl<T> ToOwned for T where
        T: Clone,     [src]

    type Owned = T

    The resulting type after obtaining ownership.

    +

    impl<T, U> TryFrom<U> for T where
        U: Into<T>,     [src]

    type Error = Infallible

    The type returned in the event of a conversion error.

    -

    impl<T, U> TryInto<U> for T where
        U: TryFrom<T>,     [src]

    type Error = <U as TryFrom<T>>::Error

    The type returned in the event of a conversion error.

    -
    \ No newline at end of file +

    impl<T, U> TryFrom<U> for T where
        U: Into<T>,     [src]

    type Error = Infallible

    The type returned in the event of a conversion error.

    +

    impl<T, U> TryInto<U> for T where
        U: TryFrom<T>,     [src]

    type Error = <U as TryFrom<T>>::Error

    The type returned in the event of a conversion error.

    +
    + \ No newline at end of file diff --git a/syn/struct.PathSegment.html b/syn/struct.PathSegment.html index 540cdfb..a960d0c 100644 --- a/syn/struct.PathSegment.html +++ b/syn/struct.PathSegment.html @@ -1,7 +1,7 @@ -syn::PathSegment - Rust +syn::PathSegment - Rust -

    [−][src]Struct syn::PathSegment

    pub struct PathSegment {
+
    Struct syn::PathSegment[−][src]
    pub struct PathSegment {
     pub ident: Ident,
     pub arguments: PathArguments,
 }
    A segment of a path together with any path arguments on that segment.
    
@@ -9,30 +9,31 @@
 feature.
    
 
    
                        Fields
    ident: Identarguments: PathArguments
    Trait Implementations
    impl Clone for PathSegment[src]
    impl Debug for PathSegment[src]
    impl Eq for PathSegment[src]
    impl<T> From<T> for PathSegment where
        T: Into<Ident>,     [src]
    impl Hash for PathSegment[src]
    impl Parse for PathSegment[src]
    impl PartialEq<PathSegment> for PathSegment[src]
    impl Parse for PathSegment[src]
    impl PartialEq<PathSegment> for PathSegment[src]
    impl ToTokens for PathSegment[src]
    Auto Trait Implementations
    Blanket Implementations
    impl<T> Any for T where
        T: 'static + ?Sized,     [src]
    impl<T> Borrow<T> for T where
        T: ?Sized,     [src]
    impl<T> BorrowMut<T> for T where
        T: ?Sized,     [src]
    impl<T> From<T> for T[src]
    impl<T, U> Into<U> for T where
        U: From<T>,     [src]
    impl ToTokens for PathSegment[src]
    Auto Trait Implementations
    Blanket Implementations
    impl<T> Any for T where
        T: 'static + ?Sized,     [src]
    impl<T> Borrow<T> for T where
        T: ?Sized,     [src]
    impl<T> BorrowMut<T> for T where
        T: ?Sized,     [src]
    impl<T> From<T> for T[src]
    impl<T, U> Into<U> for T where
        U: From<T>,     [src]
    impl<T> Spanned for T where
        T: Spanned + ?Sized,     [src]
    impl<T> ToOwned for T where
        T: Clone,     [src]
    type Owned = T
    The resulting type after obtaining ownership.
    
-
    impl<T> ToOwned for T where
        T: Clone,     [src]
    type Owned = T
    The resulting type after obtaining ownership.
    
+
    impl<T, U> TryFrom<U> for T where
        U: Into<T>,     [src]
    type Error = Infallible
    The type returned in the event of a conversion error.
    
-
    impl<T, U> TryInto<U> for T where
        U: TryFrom<T>,     [src]
    type Error = <U as TryFrom<T>>::Error
    The type returned in the event of a conversion error.
    
-
    
\ No newline at end of file
+

    impl<T, U> TryFrom<U> for T where
        U: Into<T>,     [src]

    type Error = Infallible

    The type returned in the event of a conversion error.

    +

    impl<T, U> TryInto<U> for T where
        U: TryFrom<T>,     [src]

    type Error = <U as TryFrom<T>>::Error

    The type returned in the event of a conversion error.

    +
    + \ No newline at end of file diff --git a/syn/struct.PredicateEq.html b/syn/struct.PredicateEq.html index 53d5f6b..41ac3ef 100644 --- a/syn/struct.PredicateEq.html +++ b/syn/struct.PredicateEq.html @@ -1,7 +1,7 @@ -syn::PredicateEq - Rust +syn::PredicateEq - Rust -

    [−][src]Struct syn::PredicateEq

    pub struct PredicateEq {
+
    Struct syn::PredicateEq[−][src]
    pub struct PredicateEq {
     pub lhs_ty: Type,
     pub eq_token: Eq,
     pub rhs_ty: Type,
@@ -10,30 +10,31 @@
 "full" feature.
    
 
    
                        Fields
    lhs_ty: Typeeq_token: Eqrhs_ty: Type
    Trait Implementations
    impl Clone for PredicateEq[src]
    impl Debug for PredicateEq[src]
    impl Eq for PredicateEq[src]
    impl From<PredicateEq> for WherePredicate[src]
    impl Eq for PredicateEq[src]
    impl From<PredicateEq> for WherePredicate[src]
    impl Hash for PredicateEq[src]
    impl PartialEq<PredicateEq> for PredicateEq[src]
    impl ToTokens for PredicateEq[src]
    Auto Trait Implementations
    Blanket Implementations
    impl<T> Any for T where
        T: 'static + ?Sized,     [src]
    impl<T> Borrow<T> for T where
        T: ?Sized,     [src]
    impl<T> BorrowMut<T> for T where
        T: ?Sized,     [src]
    impl<T> From<T> for T[src]
    impl<T, U> Into<U> for T where
        U: From<T>,     [src]
    impl ToTokens for PredicateEq[src]
    Auto Trait Implementations
    Blanket Implementations
    impl<T> Any for T where
        T: 'static + ?Sized,     [src]
    impl<T> Borrow<T> for T where
        T: ?Sized,     [src]
    impl<T> BorrowMut<T> for T where
        T: ?Sized,     [src]
    impl<T> From<T> for T[src]
    impl<T, U> Into<U> for T where
        U: From<T>,     [src]
    impl<T> Spanned for T where
        T: Spanned + ?Sized,     [src]
    impl<T> ToOwned for T where
        T: Clone,     [src]
    type Owned = T
    The resulting type after obtaining ownership.
    
-
    impl<T> ToOwned for T where
        T: Clone,     [src]
    type Owned = T
    The resulting type after obtaining ownership.
    
+
    impl<T, U> TryFrom<U> for T where
        U: Into<T>,     [src]
    type Error = Infallible
    The type returned in the event of a conversion error.
    
-
    impl<T, U> TryInto<U> for T where
        U: TryFrom<T>,     [src]
    type Error = <U as TryFrom<T>>::Error
    The type returned in the event of a conversion error.
    
-
    
\ No newline at end of file
+

    impl<T, U> TryFrom<U> for T where
        U: Into<T>,     [src]

    type Error = Infallible

    The type returned in the event of a conversion error.

    +

    impl<T, U> TryInto<U> for T where
        U: TryFrom<T>,     [src]

    type Error = <U as TryFrom<T>>::Error

    The type returned in the event of a conversion error.

    +
    + \ No newline at end of file diff --git a/syn/struct.PredicateLifetime.html b/syn/struct.PredicateLifetime.html index 98dbae7..59c9088 100644 --- a/syn/struct.PredicateLifetime.html +++ b/syn/struct.PredicateLifetime.html @@ -1,7 +1,7 @@ -syn::PredicateLifetime - Rust +syn::PredicateLifetime - Rust -

    [−][src]Struct syn::PredicateLifetime

    pub struct PredicateLifetime {
+
    Struct syn::PredicateLifetime[−][src]
    pub struct PredicateLifetime {
     pub lifetime: Lifetime,
     pub colon_token: Colon,
     pub bounds: Punctuated<Lifetime, Add>,
@@ -10,30 +10,31 @@
 "full" feature.
    
 
    
                        Fields
    lifetime: Lifetimecolon_token: Colonbounds: Punctuated<Lifetime, Add>
    Trait Implementations
    impl Clone for PredicateLifetime[src]
    impl Debug for PredicateLifetime[src]
    impl Eq for PredicateLifetime[src]
    impl From<PredicateLifetime> for WherePredicate[src]
    impl Eq for PredicateLifetime[src]
    impl From<PredicateLifetime> for WherePredicate[src]
    impl Hash for PredicateLifetime[src]
    impl PartialEq<PredicateLifetime> for PredicateLifetime[src]
    impl ToTokens for PredicateLifetime[src]
    Auto Trait Implementations
    Blanket Implementations
    impl<T> Any for T where
        T: 'static + ?Sized,     [src]
    impl<T> Borrow<T> for T where
        T: ?Sized,     [src]
    impl<T> BorrowMut<T> for T where
        T: ?Sized,     [src]
    impl<T> From<T> for T[src]
    impl<T, U> Into<U> for T where
        U: From<T>,     [src]
    impl ToTokens for PredicateLifetime[src]
    Auto Trait Implementations
    Blanket Implementations
    impl<T> Any for T where
        T: 'static + ?Sized,     [src]
    impl<T> Borrow<T> for T where
        T: ?Sized,     [src]
    impl<T> BorrowMut<T> for T where
        T: ?Sized,     [src]
    impl<T> From<T> for T[src]
    impl<T, U> Into<U> for T where
        U: From<T>,     [src]
    impl<T> Spanned for T where
        T: Spanned + ?Sized,     [src]
    impl<T> ToOwned for T where
        T: Clone,     [src]
    type Owned = T
    The resulting type after obtaining ownership.
    
-
    impl<T> ToOwned for T where
        T: Clone,     [src]
    type Owned = T
    The resulting type after obtaining ownership.
    
+
    impl<T, U> TryFrom<U> for T where
        U: Into<T>,     [src]
    type Error = Infallible
    The type returned in the event of a conversion error.
    
-
    impl<T, U> TryInto<U> for T where
        U: TryFrom<T>,     [src]
    type Error = <U as TryFrom<T>>::Error
    The type returned in the event of a conversion error.
    
-
    
\ No newline at end of file
+

    impl<T, U> TryFrom<U> for T where
        U: Into<T>,     [src]

    type Error = Infallible

    The type returned in the event of a conversion error.

    +

    impl<T, U> TryInto<U> for T where
        U: TryFrom<T>,     [src]

    type Error = <U as TryFrom<T>>::Error

    The type returned in the event of a conversion error.

    +
    + \ No newline at end of file diff --git a/syn/struct.PredicateType.html b/syn/struct.PredicateType.html index d835916..df2cc13 100644 --- a/syn/struct.PredicateType.html +++ b/syn/struct.PredicateType.html @@ -1,7 +1,7 @@ -syn::PredicateType - Rust +syn::PredicateType - Rust -

    [−][src]Struct syn::PredicateType

    pub struct PredicateType {
+
    Struct syn::PredicateType[−][src]
    pub struct PredicateType {
     pub lifetimes: Option<BoundLifetimes>,
     pub bounded_ty: Type,
     pub colon_token: Colon,
@@ -14,30 +14,31 @@
 
    bounded_ty: Type
    The type being bounded
    
 
    colon_token: Colonbounds: Punctuated<TypeParamBound, Add>
    Trait and lifetime bounds (Clone+Send+'static)
    
 
    Trait Implementations
    impl Clone for PredicateType[src]
    impl Debug for PredicateType[src]
    impl Eq for PredicateType[src]
    impl From<PredicateType> for WherePredicate[src]
    impl Eq for PredicateType[src]
    impl From<PredicateType> for WherePredicate[src]
    impl Hash for PredicateType[src]
    impl PartialEq<PredicateType> for PredicateType[src]
    impl ToTokens for PredicateType[src]
    Auto Trait Implementations
    Blanket Implementations
    impl<T> Any for T where
        T: 'static + ?Sized,     [src]
    impl<T> Borrow<T> for T where
        T: ?Sized,     [src]
    impl<T> BorrowMut<T> for T where
        T: ?Sized,     [src]
    impl<T> From<T> for T[src]
    impl<T, U> Into<U> for T where
        U: From<T>,     [src]
    impl ToTokens for PredicateType[src]
    Auto Trait Implementations
    Blanket Implementations
    impl<T> Any for T where
        T: 'static + ?Sized,     [src]
    impl<T> Borrow<T> for T where
        T: ?Sized,     [src]
    impl<T> BorrowMut<T> for T where
        T: ?Sized,     [src]
    impl<T> From<T> for T[src]
    impl<T, U> Into<U> for T where
        U: From<T>,     [src]
    impl<T> Spanned for T where
        T: Spanned + ?Sized,     [src]
    impl<T> ToOwned for T where
        T: Clone,     [src]
    type Owned = T
    The resulting type after obtaining ownership.
    
-
    impl<T> ToOwned for T where
        T: Clone,     [src]
    type Owned = T
    The resulting type after obtaining ownership.
    
+
    impl<T, U> TryFrom<U> for T where
        U: Into<T>,     [src]
    type Error = Infallible
    The type returned in the event of a conversion error.
    
-
    impl<T, U> TryInto<U> for T where
        U: TryFrom<T>,     [src]
    type Error = <U as TryFrom<T>>::Error
    The type returned in the event of a conversion error.
    
-
    
\ No newline at end of file
+

    impl<T, U> TryFrom<U> for T where
        U: Into<T>,     [src]

    type Error = Infallible

    The type returned in the event of a conversion error.

    +

    impl<T, U> TryInto<U> for T where
        U: TryFrom<T>,     [src]

    type Error = <U as TryFrom<T>>::Error

    The type returned in the event of a conversion error.

    +
    + \ No newline at end of file diff --git a/syn/struct.QSelf.html b/syn/struct.QSelf.html index 38b671e..6c55396 100644 --- a/syn/struct.QSelf.html +++ b/syn/struct.QSelf.html @@ -1,7 +1,7 @@ -syn::QSelf - Rust +syn::QSelf - Rust -

    [−][src]Struct syn::QSelf

    pub struct QSelf {
+
    Struct syn::QSelf[−][src]
    pub struct QSelf {
     pub lt_token: Lt,
     pub ty: Box<Type>,
     pub position: usize,
@@ -23,24 +23,25 @@ item qualified with this Self type.
    
 feature.
    
 
    
                        Fields
    lt_token: Ltty: Box<Type>position: usizeas_token: Option<As>gt_token: Gt
    Trait Implementations
    impl Clone for QSelf[src]
    impl Debug for QSelf[src]
    impl Eq for QSelf[src]
    impl Hash for QSelf[src]
    impl PartialEq<QSelf> for QSelf[src]
    Auto Trait Implementations
    Blanket Implementations
    impl<T> Any for T where
        T: 'static + ?Sized,     [src]
    impl<T> Borrow<T> for T where
        T: ?Sized,     [src]
    impl<T> BorrowMut<T> for T where
        T: ?Sized,     [src]
    impl<T> From<T> for T[src]
    impl<T, U> Into<U> for T where
        U: From<T>,     [src]
    impl<T> ToOwned for T where
        T: Clone,     [src]
    type Owned = T
    The resulting type after obtaining ownership.
    
-
    Auto Trait Implementations
    impl RefUnwindSafe for QSelf
    impl !Send for QSelf
    impl !Sync for QSelf
    impl Unpin for QSelf
    impl UnwindSafe for QSelf
    Blanket Implementations
    impl<T> Any for T where
        T: 'static + ?Sized,     [src]
    impl<T> Borrow<T> for T where
        T: ?Sized,     [src]
    impl<T> BorrowMut<T> for T where
        T: ?Sized,     [src]
    impl<T> From<T> for T[src]
    impl<T, U> Into<U> for T where
        U: From<T>,     [src]
    impl<T> ToOwned for T where
        T: Clone,     [src]
    type Owned = T
    The resulting type after obtaining ownership.
    
+
    impl<T, U> TryFrom<U> for T where
        U: Into<T>,     [src]
    type Error = Infallible
    The type returned in the event of a conversion error.
    
-
    impl<T, U> TryInto<U> for T where
        U: TryFrom<T>,     [src]
    type Error = <U as TryFrom<T>>::Error
    The type returned in the event of a conversion error.
    
-
    
\ No newline at end of file
+

    impl<T, U> TryFrom<U> for T where
        U: Into<T>,     [src]

    type Error = Infallible

    The type returned in the event of a conversion error.

    +

    impl<T, U> TryInto<U> for T where
        U: TryFrom<T>,     [src]

    type Error = <U as TryFrom<T>>::Error

    The type returned in the event of a conversion error.

    +
    + \ No newline at end of file diff --git a/syn/struct.TraitBound.html b/syn/struct.TraitBound.html index aaf3bf5..c47238d 100644 --- a/syn/struct.TraitBound.html +++ b/syn/struct.TraitBound.html @@ -1,7 +1,7 @@ -syn::TraitBound - Rust +syn::TraitBound - Rust -

    [−][src]Struct syn::TraitBound

    pub struct TraitBound {
+
    Struct syn::TraitBound[−][src]
    pub struct TraitBound {
     pub paren_token: Option<Paren>,
     pub modifier: TraitBoundModifier,
     pub lifetimes: Option<BoundLifetimes>,
@@ -13,30 +13,31 @@ feature.
    
                        Fieldsparen_token: Option<Paren>modifier: TraitBoundModifierlifetimes: Option<BoundLifetimes>
    The for<'a> in for<'a> Foo<&'a T>
    
 
    path: Path
    The Foo<&'a T> in for<'a> Foo<&'a T>
    
 
    Trait Implementations
    impl Clone for TraitBound[src]
    impl Debug for TraitBound[src]
    impl Eq for TraitBound[src]
    impl From<TraitBound> for TypeParamBound[src]
    impl Eq for TraitBound[src]
    impl From<TraitBound> for TypeParamBound[src]
    impl Hash for TraitBound[src]
    impl Parse for TraitBound[src]
    impl PartialEq<TraitBound> for TraitBound[src]
    impl Parse for TraitBound[src]
    impl PartialEq<TraitBound> for TraitBound[src]
    impl ToTokens for TraitBound[src]
    Auto Trait Implementations
    Blanket Implementations
    impl<T> Any for T where
        T: 'static + ?Sized,     [src]
    impl<T> Borrow<T> for T where
        T: ?Sized,     [src]
    impl<T> BorrowMut<T> for T where
        T: ?Sized,     [src]
    impl<T> From<T> for T[src]
    impl<T, U> Into<U> for T where
        U: From<T>,     [src]
    impl ToTokens for TraitBound[src]
    Auto Trait Implementations
    Blanket Implementations
    impl<T> Any for T where
        T: 'static + ?Sized,     [src]
    impl<T> Borrow<T> for T where
        T: ?Sized,     [src]
    impl<T> BorrowMut<T> for T where
        T: ?Sized,     [src]
    impl<T> From<T> for T[src]
    impl<T, U> Into<U> for T where
        U: From<T>,     [src]
    impl<T> Spanned for T where
        T: Spanned + ?Sized,     [src]
    impl<T> ToOwned for T where
        T: Clone,     [src]
    type Owned = T
    The resulting type after obtaining ownership.
    
-
    impl<T> ToOwned for T where
        T: Clone,     [src]
    type Owned = T
    The resulting type after obtaining ownership.
    
+
    impl<T, U> TryFrom<U> for T where
        U: Into<T>,     [src]
    type Error = Infallible
    The type returned in the event of a conversion error.
    
-
    impl<T, U> TryInto<U> for T where
        U: TryFrom<T>,     [src]
    type Error = <U as TryFrom<T>>::Error
    The type returned in the event of a conversion error.
    
-
    
\ No newline at end of file
+

    impl<T, U> TryFrom<U> for T where
        U: Into<T>,     [src]

    type Error = Infallible

    The type returned in the event of a conversion error.

    +

    impl<T, U> TryInto<U> for T where
        U: TryFrom<T>,     [src]

    type Error = <U as TryFrom<T>>::Error

    The type returned in the event of a conversion error.

    +
    + \ No newline at end of file diff --git a/syn/struct.Turbofish.html b/syn/struct.Turbofish.html index 6f2374c..1f0d0a6 100644 --- a/syn/struct.Turbofish.html +++ b/syn/struct.Turbofish.html @@ -1,33 +1,34 @@ -syn::Turbofish - Rust +syn::Turbofish - Rust -

    [−][src]Struct syn::Turbofish

    pub struct Turbofish<'a>(_);

    Returned by TypeGenerics::as_turbofish.

    +

    Struct syn::Turbofish[−][src]

    pub struct Turbofish<'a>(_);

    Returned by TypeGenerics::as_turbofish.

    This type is available only if Syn is built with the "derive" or "full" feature and the "printing" feature.

    -

    Trait Implementations

    impl<'a> Clone for Turbofish<'a>[src]

    impl<'a> Debug for Turbofish<'a>[src]

    impl<'a> Eq for Turbofish<'a>[src]

    impl<'a> Hash for Turbofish<'a>[src]

    impl<'a> PartialEq<Turbofish<'a>> for Turbofish<'a>[src]

    Trait Implementations

    impl<'a> Clone for Turbofish<'a>[src]

    impl<'a> Debug for Turbofish<'a>[src]

    impl<'a> Eq for Turbofish<'a>[src]

    impl<'a> Hash for Turbofish<'a>[src]

    impl<'a> PartialEq<Turbofish<'a>> for Turbofish<'a>[src]

    impl<'a> ToTokens for Turbofish<'a>[src]

    Auto Trait Implementations

    impl<'a> RefUnwindSafe for Turbofish<'a>[src]

    impl<'a> !Send for Turbofish<'a>[src]

    impl<'a> !Sync for Turbofish<'a>[src]

    impl<'a> Unpin for Turbofish<'a>[src]

    impl<'a> UnwindSafe for Turbofish<'a>[src]

    Blanket Implementations

    impl<T> Any for T where
        T: 'static + ?Sized,     [src]

    impl<T> Borrow<T> for T where
        T: ?Sized,     [src]

    impl<T> BorrowMut<T> for T where
        T: ?Sized,     [src]

    impl<T> From<T> for T[src]

    impl<T, U> Into<U> for T where
        U: From<T>,     [src]

    impl<'a> ToTokens for Turbofish<'a>[src]

    Auto Trait Implementations

    impl<'a> RefUnwindSafe for Turbofish<'a>

    impl<'a> !Send for Turbofish<'a>

    impl<'a> !Sync for Turbofish<'a>

    impl<'a> Unpin for Turbofish<'a>

    impl<'a> UnwindSafe for Turbofish<'a>

    Blanket Implementations

    impl<T> Any for T where
        T: 'static + ?Sized,     [src]

    impl<T> Borrow<T> for T where
        T: ?Sized,     [src]

    impl<T> BorrowMut<T> for T where
        T: ?Sized,     [src]

    impl<T> From<T> for T[src]

    impl<T, U> Into<U> for T where
        U: From<T>,     [src]

    impl<T> Spanned for T where
        T: Spanned + ?Sized,     [src]

    impl<T> ToOwned for T where
        T: Clone,     [src]

    type Owned = T

    The resulting type after obtaining ownership.

    -

    impl<T> ToOwned for T where
        T: Clone,     [src]

    type Owned = T

    The resulting type after obtaining ownership.

    +

    impl<T, U> TryFrom<U> for T where
        U: Into<T>,     [src]

    type Error = Infallible

    The type returned in the event of a conversion error.

    -

    impl<T, U> TryInto<U> for T where
        U: TryFrom<T>,     [src]

    type Error = <U as TryFrom<T>>::Error

    The type returned in the event of a conversion error.

    -
    \ No newline at end of file +

    impl<T, U> TryFrom<U> for T where
        U: Into<T>,     [src]

    type Error = Infallible

    The type returned in the event of a conversion error.

    +

    impl<T, U> TryInto<U> for T where
        U: TryFrom<T>,     [src]

    type Error = <U as TryFrom<T>>::Error

    The type returned in the event of a conversion error.

    +
    + \ No newline at end of file diff --git a/syn/struct.TypeArray.html b/syn/struct.TypeArray.html index 2ed69bc..6ba7f9e 100644 --- a/syn/struct.TypeArray.html +++ b/syn/struct.TypeArray.html @@ -1,7 +1,7 @@ -syn::TypeArray - Rust +syn::TypeArray - Rust -

    [−][src]Struct syn::TypeArray

    pub struct TypeArray {
+
    Struct syn::TypeArray[−][src]
    pub struct TypeArray {
     pub bracket_token: Bracket,
     pub elem: Box<Type>,
     pub semi_token: Semi,
@@ -11,30 +11,31 @@
 "full" feature.
    
 
    
                        Fields
    bracket_token: Bracketelem: Box<Type>semi_token: Semilen: Expr
    Trait Implementations
    impl Clone for TypeArray[src]
    impl Debug for TypeArray[src]
    impl Eq for TypeArray[src]
    impl From<TypeArray> for Type[src]
    impl Hash for TypeArray[src]
    impl Parse for TypeArray[src]
    impl PartialEq<TypeArray> for TypeArray[src]
    impl Parse for TypeArray[src]
    impl PartialEq<TypeArray> for TypeArray[src]
    impl ToTokens for TypeArray[src]
    Auto Trait Implementations
    Blanket Implementations
    impl<T> Any for T where
        T: 'static + ?Sized,     [src]
    impl<T> Borrow<T> for T where
        T: ?Sized,     [src]
    impl<T> BorrowMut<T> for T where
        T: ?Sized,     [src]
    impl<T> From<T> for T[src]
    impl<T, U> Into<U> for T where
        U: From<T>,     [src]
    impl ToTokens for TypeArray[src]
    Auto Trait Implementations
    Blanket Implementations
    impl<T> Any for T where
        T: 'static + ?Sized,     [src]
    impl<T> Borrow<T> for T where
        T: ?Sized,     [src]
    impl<T> BorrowMut<T> for T where
        T: ?Sized,     [src]
    impl<T> From<T> for T[src]
    impl<T, U> Into<U> for T where
        U: From<T>,     [src]
    impl<T> Spanned for T where
        T: Spanned + ?Sized,     [src]
    impl<T> ToOwned for T where
        T: Clone,     [src]
    type Owned = T
    The resulting type after obtaining ownership.
    
-
    impl<T> ToOwned for T where
        T: Clone,     [src]
    type Owned = T
    The resulting type after obtaining ownership.
    
+
    impl<T, U> TryFrom<U> for T where
        U: Into<T>,     [src]
    type Error = Infallible
    The type returned in the event of a conversion error.
    
-
    impl<T, U> TryInto<U> for T where
        U: TryFrom<T>,     [src]
    type Error = <U as TryFrom<T>>::Error
    The type returned in the event of a conversion error.
    
-
    
\ No newline at end of file
+

    impl<T, U> TryFrom<U> for T where
        U: Into<T>,     [src]

    type Error = Infallible

    The type returned in the event of a conversion error.

    +

    impl<T, U> TryInto<U> for T where
        U: TryFrom<T>,     [src]

    type Error = <U as TryFrom<T>>::Error

    The type returned in the event of a conversion error.

    +
    + \ No newline at end of file diff --git a/syn/struct.TypeBareFn.html b/syn/struct.TypeBareFn.html index 99e1d0e..0fe6a28 100644 --- a/syn/struct.TypeBareFn.html +++ b/syn/struct.TypeBareFn.html @@ -1,7 +1,7 @@ -syn::TypeBareFn - Rust +syn::TypeBareFn - Rust -

    [−][src]Struct syn::TypeBareFn

    pub struct TypeBareFn {
+
    Struct syn::TypeBareFn[−][src]
    pub struct TypeBareFn {
     pub lifetimes: Option<BoundLifetimes>,
     pub unsafety: Option<Unsafe>,
     pub abi: Option<Abi>,
@@ -15,30 +15,31 @@
 "full" feature.
    
 
    
                        Fields
    lifetimes: Option<BoundLifetimes>unsafety: Option<Unsafe>abi: Option<Abi>fn_token: Fnparen_token: Pareninputs: Punctuated<BareFnArg, Comma>variadic: Option<Variadic>output: ReturnType
    Trait Implementations
    impl Clone for TypeBareFn[src]
    impl Debug for TypeBareFn[src]
    impl Eq for TypeBareFn[src]
    impl From<TypeBareFn> for Type[src]
    impl Hash for TypeBareFn[src]
    impl Parse for TypeBareFn[src]
    impl PartialEq<TypeBareFn> for TypeBareFn[src]
    impl Parse for TypeBareFn[src]
    impl PartialEq<TypeBareFn> for TypeBareFn[src]
    impl ToTokens for TypeBareFn[src]
    Auto Trait Implementations
    Blanket Implementations
    impl<T> Any for T where
        T: 'static + ?Sized,     [src]
    impl<T> Borrow<T> for T where
        T: ?Sized,     [src]
    impl<T> BorrowMut<T> for T where
        T: ?Sized,     [src]
    impl<T> From<T> for T[src]
    impl<T, U> Into<U> for T where
        U: From<T>,     [src]
    impl ToTokens for TypeBareFn[src]
    Auto Trait Implementations
    Blanket Implementations
    impl<T> Any for T where
        T: 'static + ?Sized,     [src]
    impl<T> Borrow<T> for T where
        T: ?Sized,     [src]
    impl<T> BorrowMut<T> for T where
        T: ?Sized,     [src]
    impl<T> From<T> for T[src]
    impl<T, U> Into<U> for T where
        U: From<T>,     [src]
    impl<T> Spanned for T where
        T: Spanned + ?Sized,     [src]
    impl<T> ToOwned for T where
        T: Clone,     [src]
    type Owned = T
    The resulting type after obtaining ownership.
    
-
    impl<T> ToOwned for T where
        T: Clone,     [src]
    type Owned = T
    The resulting type after obtaining ownership.
    
+
    impl<T, U> TryFrom<U> for T where
        U: Into<T>,     [src]
    type Error = Infallible
    The type returned in the event of a conversion error.
    
-
    impl<T, U> TryInto<U> for T where
        U: TryFrom<T>,     [src]
    type Error = <U as TryFrom<T>>::Error
    The type returned in the event of a conversion error.
    
-
    
\ No newline at end of file
+

    impl<T, U> TryFrom<U> for T where
        U: Into<T>,     [src]

    type Error = Infallible

    The type returned in the event of a conversion error.

    +

    impl<T, U> TryInto<U> for T where
        U: TryFrom<T>,     [src]

    type Error = <U as TryFrom<T>>::Error

    The type returned in the event of a conversion error.

    +
    + \ No newline at end of file diff --git a/syn/struct.TypeGenerics.html b/syn/struct.TypeGenerics.html index be3abc2..748d1ba 100644 --- a/syn/struct.TypeGenerics.html +++ b/syn/struct.TypeGenerics.html @@ -1,36 +1,37 @@ -syn::TypeGenerics - Rust +syn::TypeGenerics - Rust -

    [−][src]Struct syn::TypeGenerics

    pub struct TypeGenerics<'a>(_);

    Returned by Generics::split_for_impl.

    +

    Struct syn::TypeGenerics[−][src]

    pub struct TypeGenerics<'a>(_);

    Returned by Generics::split_for_impl.

    This type is available only if Syn is built with the "derive" or "full" feature and the "printing" feature.

    -

    Implementations

    impl<'a> TypeGenerics<'a>[src]

    pub fn as_turbofish(&self) -> Turbofish<'_>[src]

    Turn a type's generics like <X, Y> into a turbofish like ::<X, Y>.

    +

    Implementations

    impl<'a> TypeGenerics<'a>[src]

    pub fn as_turbofish(&self) -> Turbofish<'_>[src]

    Turn a type’s generics like <X, Y> into a turbofish like ::<X, Y>.

    This method is available only if Syn is built with the "derive" or "full" feature and the "printing" feature.

    -

    Trait Implementations

    impl<'a> Clone for TypeGenerics<'a>[src]

    impl<'a> Debug for TypeGenerics<'a>[src]

    impl<'a> Eq for TypeGenerics<'a>[src]

    impl<'a> Hash for TypeGenerics<'a>[src]

    impl<'a> PartialEq<TypeGenerics<'a>> for TypeGenerics<'a>[src]

    Trait Implementations

    impl<'a> Clone for TypeGenerics<'a>[src]

    impl<'a> Debug for TypeGenerics<'a>[src]

    impl<'a> Eq for TypeGenerics<'a>[src]

    impl<'a> Hash for TypeGenerics<'a>[src]

    impl<'a> PartialEq<TypeGenerics<'a>> for TypeGenerics<'a>[src]

    impl<'a> ToTokens for TypeGenerics<'a>[src]

    Auto Trait Implementations

    impl<'a> RefUnwindSafe for TypeGenerics<'a>[src]

    impl<'a> !Send for TypeGenerics<'a>[src]

    impl<'a> !Sync for TypeGenerics<'a>[src]

    impl<'a> Unpin for TypeGenerics<'a>[src]

    impl<'a> UnwindSafe for TypeGenerics<'a>[src]

    Blanket Implementations

    impl<T> Any for T where
        T: 'static + ?Sized,     [src]

    impl<T> Borrow<T> for T where
        T: ?Sized,     [src]

    impl<T> BorrowMut<T> for T where
        T: ?Sized,     [src]

    impl<T> From<T> for T[src]

    impl<T, U> Into<U> for T where
        U: From<T>,     [src]

    impl<'a> ToTokens for TypeGenerics<'a>[src]

    Auto Trait Implementations

    impl<'a> RefUnwindSafe for TypeGenerics<'a>

    impl<'a> !Send for TypeGenerics<'a>

    impl<'a> !Sync for TypeGenerics<'a>

    impl<'a> Unpin for TypeGenerics<'a>

    impl<'a> UnwindSafe for TypeGenerics<'a>

    Blanket Implementations

    impl<T> Any for T where
        T: 'static + ?Sized,     [src]

    impl<T> Borrow<T> for T where
        T: ?Sized,     [src]

    impl<T> BorrowMut<T> for T where
        T: ?Sized,     [src]

    impl<T> From<T> for T[src]

    impl<T, U> Into<U> for T where
        U: From<T>,     [src]

    impl<T> Spanned for T where
        T: Spanned + ?Sized,     [src]

    impl<T> ToOwned for T where
        T: Clone,     [src]

    type Owned = T

    The resulting type after obtaining ownership.

    -

    impl<T> ToOwned for T where
        T: Clone,     [src]

    type Owned = T

    The resulting type after obtaining ownership.

    +

    impl<T, U> TryFrom<U> for T where
        U: Into<T>,     [src]

    type Error = Infallible

    The type returned in the event of a conversion error.

    -

    impl<T, U> TryInto<U> for T where
        U: TryFrom<T>,     [src]

    type Error = <U as TryFrom<T>>::Error

    The type returned in the event of a conversion error.

    -
    \ No newline at end of file +

    impl<T, U> TryFrom<U> for T where
        U: Into<T>,     [src]

    type Error = Infallible

    The type returned in the event of a conversion error.

    +

    impl<T, U> TryInto<U> for T where
        U: TryFrom<T>,     [src]

    type Error = <U as TryFrom<T>>::Error

    The type returned in the event of a conversion error.

    +
    + \ No newline at end of file diff --git a/syn/struct.TypeGroup.html b/syn/struct.TypeGroup.html index 993545e..9f18ede 100644 --- a/syn/struct.TypeGroup.html +++ b/syn/struct.TypeGroup.html @@ -1,7 +1,7 @@ -syn::TypeGroup - Rust +syn::TypeGroup - Rust -

    [−][src]Struct syn::TypeGroup

    pub struct TypeGroup {
+
    Struct syn::TypeGroup[−][src]
    pub struct TypeGroup {
     pub group_token: Group,
     pub elem: Box<Type>,
 }
    A type contained within invisible delimiters.
    
@@ -9,30 +9,31 @@
 "full" feature.
    
 
    
                        Fields
    group_token: Groupelem: Box<Type>
    Trait Implementations
    impl Clone for TypeGroup[src]
    impl Debug for TypeGroup[src]
    impl Eq for TypeGroup[src]
    impl From<TypeGroup> for Type[src]
    impl Hash for TypeGroup[src]
    impl Parse for TypeGroup[src]
    impl PartialEq<TypeGroup> for TypeGroup[src]
    impl Parse for TypeGroup[src]
    impl PartialEq<TypeGroup> for TypeGroup[src]
    impl ToTokens for TypeGroup[src]
    Auto Trait Implementations
    Blanket Implementations
    impl<T> Any for T where
        T: 'static + ?Sized,     [src]
    impl<T> Borrow<T> for T where
        T: ?Sized,     [src]
    impl<T> BorrowMut<T> for T where
        T: ?Sized,     [src]
    impl<T> From<T> for T[src]
    impl<T, U> Into<U> for T where
        U: From<T>,     [src]
    impl ToTokens for TypeGroup[src]
    Auto Trait Implementations
    Blanket Implementations
    impl<T> Any for T where
        T: 'static + ?Sized,     [src]
    impl<T> Borrow<T> for T where
        T: ?Sized,     [src]
    impl<T> BorrowMut<T> for T where
        T: ?Sized,     [src]
    impl<T> From<T> for T[src]
    impl<T, U> Into<U> for T where
        U: From<T>,     [src]
    impl<T> Spanned for T where
        T: Spanned + ?Sized,     [src]
    impl<T> ToOwned for T where
        T: Clone,     [src]
    type Owned = T
    The resulting type after obtaining ownership.
    
-
    impl<T> ToOwned for T where
        T: Clone,     [src]
    type Owned = T
    The resulting type after obtaining ownership.
    
+
    impl<T, U> TryFrom<U> for T where
        U: Into<T>,     [src]
    type Error = Infallible
    The type returned in the event of a conversion error.
    
-
    impl<T, U> TryInto<U> for T where
        U: TryFrom<T>,     [src]
    type Error = <U as TryFrom<T>>::Error
    The type returned in the event of a conversion error.
    
-
    
\ No newline at end of file
+

    impl<T, U> TryFrom<U> for T where
        U: Into<T>,     [src]

    type Error = Infallible

    The type returned in the event of a conversion error.

    +

    impl<T, U> TryInto<U> for T where
        U: TryFrom<T>,     [src]

    type Error = <U as TryFrom<T>>::Error

    The type returned in the event of a conversion error.

    +
    + \ No newline at end of file diff --git a/syn/struct.TypeImplTrait.html b/syn/struct.TypeImplTrait.html index a3336f3..0889168 100644 --- a/syn/struct.TypeImplTrait.html +++ b/syn/struct.TypeImplTrait.html @@ -1,7 +1,7 @@ -syn::TypeImplTrait - Rust +syn::TypeImplTrait - Rust -

    [−][src]Struct syn::TypeImplTrait

    pub struct TypeImplTrait {
+
    Struct syn::TypeImplTrait[−][src]
    pub struct TypeImplTrait {
     pub impl_token: Impl,
     pub bounds: Punctuated<TypeParamBound, Add>,
 }
    An impl Bound1 + Bound2 + Bound3 type where Bound is a trait or
@@ -10,30 +10,31 @@ a lifetime.
    
 "full" feature.
    
 
    
                        Fields
    impl_token: Implbounds: Punctuated<TypeParamBound, Add>
    Trait Implementations
    impl Clone for TypeImplTrait[src]
    impl Debug for TypeImplTrait[src]
    impl Eq for TypeImplTrait[src]
    impl From<TypeImplTrait> for Type[src]
    impl Hash for TypeImplTrait[src]
    impl Parse for TypeImplTrait[src]
    impl PartialEq<TypeImplTrait> for TypeImplTrait[src]
    impl Parse for TypeImplTrait[src]
    impl PartialEq<TypeImplTrait> for TypeImplTrait[src]
    impl ToTokens for TypeImplTrait[src]
    Auto Trait Implementations
    Blanket Implementations
    impl<T> Any for T where
        T: 'static + ?Sized,     [src]
    impl<T> Borrow<T> for T where
        T: ?Sized,     [src]
    impl<T> BorrowMut<T> for T where
        T: ?Sized,     [src]
    impl<T> From<T> for T[src]
    impl<T, U> Into<U> for T where
        U: From<T>,     [src]
    impl ToTokens for TypeImplTrait[src]
    Auto Trait Implementations
    Blanket Implementations
    impl<T> Any for T where
        T: 'static + ?Sized,     [src]
    impl<T> Borrow<T> for T where
        T: ?Sized,     [src]
    impl<T> BorrowMut<T> for T where
        T: ?Sized,     [src]
    impl<T> From<T> for T[src]
    impl<T, U> Into<U> for T where
        U: From<T>,     [src]
    impl<T> Spanned for T where
        T: Spanned + ?Sized,     [src]
    impl<T> ToOwned for T where
        T: Clone,     [src]
    type Owned = T
    The resulting type after obtaining ownership.
    
-
    impl<T> ToOwned for T where
        T: Clone,     [src]
    type Owned = T
    The resulting type after obtaining ownership.
    
+
    impl<T, U> TryFrom<U> for T where
        U: Into<T>,     [src]
    type Error = Infallible
    The type returned in the event of a conversion error.
    
-
    impl<T, U> TryInto<U> for T where
        U: TryFrom<T>,     [src]
    type Error = <U as TryFrom<T>>::Error
    The type returned in the event of a conversion error.
    
-
    
\ No newline at end of file
+

    impl<T, U> TryFrom<U> for T where
        U: Into<T>,     [src]

    type Error = Infallible

    The type returned in the event of a conversion error.

    +

    impl<T, U> TryInto<U> for T where
        U: TryFrom<T>,     [src]

    type Error = <U as TryFrom<T>>::Error

    The type returned in the event of a conversion error.

    +
    + \ No newline at end of file diff --git a/syn/struct.TypeInfer.html b/syn/struct.TypeInfer.html index 1dfd3fd..f486e80 100644 --- a/syn/struct.TypeInfer.html +++ b/syn/struct.TypeInfer.html @@ -1,37 +1,38 @@ -syn::TypeInfer - Rust +syn::TypeInfer - Rust -

    [−][src]Struct syn::TypeInfer

    pub struct TypeInfer {
+
    Struct syn::TypeInfer[−][src]
    pub struct TypeInfer {
     pub underscore_token: Underscore,
 }
    Indication that a type should be inferred by the compiler: _.
    
 
    This type is available only if Syn is built with the "derive" or
 "full" feature.
    
 
    
                        Fields
    underscore_token: Underscore
    Trait Implementations
    impl Clone for TypeInfer[src]
    impl Debug for TypeInfer[src]
    impl Eq for TypeInfer[src]
    impl From<TypeInfer> for Type[src]
    impl Hash for TypeInfer[src]
    impl Parse for TypeInfer[src]
    impl PartialEq<TypeInfer> for TypeInfer[src]
    impl Parse for TypeInfer[src]
    impl PartialEq<TypeInfer> for TypeInfer[src]
    impl ToTokens for TypeInfer[src]
    Auto Trait Implementations
    Blanket Implementations
    impl<T> Any for T where
        T: 'static + ?Sized,     [src]
    impl<T> Borrow<T> for T where
        T: ?Sized,     [src]
    impl<T> BorrowMut<T> for T where
        T: ?Sized,     [src]
    impl<T> From<T> for T[src]
    impl<T, U> Into<U> for T where
        U: From<T>,     [src]
    impl ToTokens for TypeInfer[src]
    Auto Trait Implementations
    Blanket Implementations
    impl<T> Any for T where
        T: 'static + ?Sized,     [src]
    impl<T> Borrow<T> for T where
        T: ?Sized,     [src]
    impl<T> BorrowMut<T> for T where
        T: ?Sized,     [src]
    impl<T> From<T> for T[src]
    impl<T, U> Into<U> for T where
        U: From<T>,     [src]
    impl<T> Spanned for T where
        T: Spanned + ?Sized,     [src]
    impl<T> ToOwned for T where
        T: Clone,     [src]
    type Owned = T
    The resulting type after obtaining ownership.
    
-
    impl<T> ToOwned for T where
        T: Clone,     [src]
    type Owned = T
    The resulting type after obtaining ownership.
    
+
    impl<T, U> TryFrom<U> for T where
        U: Into<T>,     [src]
    type Error = Infallible
    The type returned in the event of a conversion error.
    
-
    impl<T, U> TryInto<U> for T where
        U: TryFrom<T>,     [src]
    type Error = <U as TryFrom<T>>::Error
    The type returned in the event of a conversion error.
    
-
    
\ No newline at end of file
+

    impl<T, U> TryFrom<U> for T where
        U: Into<T>,     [src]

    type Error = Infallible

    The type returned in the event of a conversion error.

    +

    impl<T, U> TryInto<U> for T where
        U: TryFrom<T>,     [src]

    type Error = <U as TryFrom<T>>::Error

    The type returned in the event of a conversion error.

    +
    + \ No newline at end of file diff --git a/syn/struct.TypeMacro.html b/syn/struct.TypeMacro.html index 45f665f..38ae27e 100644 --- a/syn/struct.TypeMacro.html +++ b/syn/struct.TypeMacro.html @@ -1,37 +1,38 @@ -syn::TypeMacro - Rust +syn::TypeMacro - Rust -

    [−][src]Struct syn::TypeMacro

    pub struct TypeMacro {
+
    Struct syn::TypeMacro[−][src]
    pub struct TypeMacro {
     pub mac: Macro,
 }
    A macro in the type position.
    
 
    This type is available only if Syn is built with the "derive" or
 "full" feature.
    
 
    
                        Fields
    mac: Macro
    Trait Implementations
    impl Clone for TypeMacro[src]
    impl Debug for TypeMacro[src]
    impl Eq for TypeMacro[src]
    impl From<TypeMacro> for Type[src]
    impl Hash for TypeMacro[src]
    impl Parse for TypeMacro[src]
    impl PartialEq<TypeMacro> for TypeMacro[src]
    impl Parse for TypeMacro[src]
    impl PartialEq<TypeMacro> for TypeMacro[src]
    impl ToTokens for TypeMacro[src]
    Auto Trait Implementations
    Blanket Implementations
    impl<T> Any for T where
        T: 'static + ?Sized,     [src]
    impl<T> Borrow<T> for T where
        T: ?Sized,     [src]
    impl<T> BorrowMut<T> for T where
        T: ?Sized,     [src]
    impl<T> From<T> for T[src]
    impl<T, U> Into<U> for T where
        U: From<T>,     [src]
    impl ToTokens for TypeMacro[src]
    Auto Trait Implementations
    Blanket Implementations
    impl<T> Any for T where
        T: 'static + ?Sized,     [src]
    impl<T> Borrow<T> for T where
        T: ?Sized,     [src]
    impl<T> BorrowMut<T> for T where
        T: ?Sized,     [src]
    impl<T> From<T> for T[src]
    impl<T, U> Into<U> for T where
        U: From<T>,     [src]
    impl<T> Spanned for T where
        T: Spanned + ?Sized,     [src]
    impl<T> ToOwned for T where
        T: Clone,     [src]
    type Owned = T
    The resulting type after obtaining ownership.
    
-
    impl<T> ToOwned for T where
        T: Clone,     [src]
    type Owned = T
    The resulting type after obtaining ownership.
    
+
    impl<T, U> TryFrom<U> for T where
        U: Into<T>,     [src]
    type Error = Infallible
    The type returned in the event of a conversion error.
    
-
    impl<T, U> TryInto<U> for T where
        U: TryFrom<T>,     [src]
    type Error = <U as TryFrom<T>>::Error
    The type returned in the event of a conversion error.
    
-
    
\ No newline at end of file
+

    impl<T, U> TryFrom<U> for T where
        U: Into<T>,     [src]

    type Error = Infallible

    The type returned in the event of a conversion error.

    +

    impl<T, U> TryInto<U> for T where
        U: TryFrom<T>,     [src]

    type Error = <U as TryFrom<T>>::Error

    The type returned in the event of a conversion error.

    +
    + \ No newline at end of file diff --git a/syn/struct.TypeNever.html b/syn/struct.TypeNever.html index 234cdbc..649cc83 100644 --- a/syn/struct.TypeNever.html +++ b/syn/struct.TypeNever.html @@ -1,37 +1,38 @@ -syn::TypeNever - Rust +syn::TypeNever - Rust -

    [−][src]Struct syn::TypeNever

    pub struct TypeNever {
+
    Struct syn::TypeNever[−][src]
    pub struct TypeNever {
     pub bang_token: Bang,
 }
    The never type: !.
    
 
    This type is available only if Syn is built with the "derive" or
 "full" feature.
    
 
    
                        Fields
    bang_token: Bang
    Trait Implementations
    impl Clone for TypeNever[src]
    impl Debug for TypeNever[src]
    impl Eq for TypeNever[src]
    impl From<TypeNever> for Type[src]
    impl Hash for TypeNever[src]
    impl Parse for TypeNever[src]
    impl PartialEq<TypeNever> for TypeNever[src]
    impl Parse for TypeNever[src]
    impl PartialEq<TypeNever> for TypeNever[src]
    impl ToTokens for TypeNever[src]
    Auto Trait Implementations
    Blanket Implementations
    impl<T> Any for T where
        T: 'static + ?Sized,     [src]
    impl<T> Borrow<T> for T where
        T: ?Sized,     [src]
    impl<T> BorrowMut<T> for T where
        T: ?Sized,     [src]
    impl<T> From<T> for T[src]
    impl<T, U> Into<U> for T where
        U: From<T>,     [src]
    impl ToTokens for TypeNever[src]
    Auto Trait Implementations
    Blanket Implementations
    impl<T> Any for T where
        T: 'static + ?Sized,     [src]
    impl<T> Borrow<T> for T where
        T: ?Sized,     [src]
    impl<T> BorrowMut<T> for T where
        T: ?Sized,     [src]
    impl<T> From<T> for T[src]
    impl<T, U> Into<U> for T where
        U: From<T>,     [src]
    impl<T> Spanned for T where
        T: Spanned + ?Sized,     [src]
    impl<T> ToOwned for T where
        T: Clone,     [src]
    type Owned = T
    The resulting type after obtaining ownership.
    
-
    impl<T> ToOwned for T where
        T: Clone,     [src]
    type Owned = T
    The resulting type after obtaining ownership.
    
+
    impl<T, U> TryFrom<U> for T where
        U: Into<T>,     [src]
    type Error = Infallible
    The type returned in the event of a conversion error.
    
-
    impl<T, U> TryInto<U> for T where
        U: TryFrom<T>,     [src]
    type Error = <U as TryFrom<T>>::Error
    The type returned in the event of a conversion error.
    
-
    
\ No newline at end of file
+

    impl<T, U> TryFrom<U> for T where
        U: Into<T>,     [src]

    type Error = Infallible

    The type returned in the event of a conversion error.

    +

    impl<T, U> TryInto<U> for T where
        U: TryFrom<T>,     [src]

    type Error = <U as TryFrom<T>>::Error

    The type returned in the event of a conversion error.

    +
    + \ No newline at end of file diff --git a/syn/struct.TypeParam.html b/syn/struct.TypeParam.html index d6ad6ff..429ef4e 100644 --- a/syn/struct.TypeParam.html +++ b/syn/struct.TypeParam.html @@ -1,7 +1,7 @@ -syn::TypeParam - Rust +syn::TypeParam - Rust -

    [−][src]Struct syn::TypeParam

    pub struct TypeParam {
+
    Struct syn::TypeParam[−][src]
    pub struct TypeParam {
     pub attrs: Vec<Attribute>,
     pub ident: Ident,
     pub colon_token: Option<Colon>,
@@ -13,31 +13,32 @@
 "full" feature.
    
 
    
                        Fields
    attrs: Vec<Attribute>ident: Identcolon_token: Option<Colon>bounds: Punctuated<TypeParamBound, Add>eq_token: Option<Eq>default: Option<Type>
    Trait Implementations
    impl Clone for TypeParam[src]
    impl Debug for TypeParam[src]
    impl Eq for TypeParam[src]
    impl From<Ident> for TypeParam[src]
    impl Eq for TypeParam[src]
    impl From<Ident> for TypeParam[src]
    impl From<TypeParam> for GenericParam[src]
    impl Hash for TypeParam[src]
    impl Parse for TypeParam[src]
    impl PartialEq<TypeParam> for TypeParam[src]
    impl Parse for TypeParam[src]
    impl PartialEq<TypeParam> for TypeParam[src]
    impl ToTokens for TypeParam[src]
    Auto Trait Implementations
    Blanket Implementations
    impl<T> Any for T where
        T: 'static + ?Sized,     [src]
    impl<T> Borrow<T> for T where
        T: ?Sized,     [src]
    impl<T> BorrowMut<T> for T where
        T: ?Sized,     [src]
    impl<T> From<T> for T[src]
    impl<T, U> Into<U> for T where
        U: From<T>,     [src]
    impl ToTokens for TypeParam[src]
    Auto Trait Implementations
    Blanket Implementations
    impl<T> Any for T where
        T: 'static + ?Sized,     [src]
    impl<T> Borrow<T> for T where
        T: ?Sized,     [src]
    impl<T> BorrowMut<T> for T where
        T: ?Sized,     [src]
    impl<T> From<T> for T[src]
    impl<T, U> Into<U> for T where
        U: From<T>,     [src]
    impl<T> Spanned for T where
        T: Spanned + ?Sized,     [src]
    impl<T> ToOwned for T where
        T: Clone,     [src]
    type Owned = T
    The resulting type after obtaining ownership.
    
-
    impl<T> ToOwned for T where
        T: Clone,     [src]
    type Owned = T
    The resulting type after obtaining ownership.
    
+
    impl<T, U> TryFrom<U> for T where
        U: Into<T>,     [src]
    type Error = Infallible
    The type returned in the event of a conversion error.
    
-
    impl<T, U> TryInto<U> for T where
        U: TryFrom<T>,     [src]
    type Error = <U as TryFrom<T>>::Error
    The type returned in the event of a conversion error.
    
-
    
\ No newline at end of file
+

    impl<T, U> TryFrom<U> for T where
        U: Into<T>,     [src]

    type Error = Infallible

    The type returned in the event of a conversion error.

    +

    impl<T, U> TryInto<U> for T where
        U: TryFrom<T>,     [src]

    type Error = <U as TryFrom<T>>::Error

    The type returned in the event of a conversion error.

    +
    + \ No newline at end of file diff --git a/syn/struct.TypeParen.html b/syn/struct.TypeParen.html index 93f862e..bcb1b93 100644 --- a/syn/struct.TypeParen.html +++ b/syn/struct.TypeParen.html @@ -1,7 +1,7 @@ -syn::TypeParen - Rust +syn::TypeParen - Rust -

    [−][src]Struct syn::TypeParen

    pub struct TypeParen {
+
    Struct syn::TypeParen[−][src]
    pub struct TypeParen {
     pub paren_token: Paren,
     pub elem: Box<Type>,
 }
    A parenthesized type equivalent to the inner type.
    
@@ -9,30 +9,31 @@
 "full" feature.
    
 
    
                        Fields
    paren_token: Parenelem: Box<Type>
    Trait Implementations
    impl Clone for TypeParen[src]
    impl Debug for TypeParen[src]
    impl Eq for TypeParen[src]
    impl From<TypeParen> for Type[src]
    impl Hash for TypeParen[src]
    impl Parse for TypeParen[src]
    impl PartialEq<TypeParen> for TypeParen[src]
    impl Parse for TypeParen[src]
    impl PartialEq<TypeParen> for TypeParen[src]
    impl ToTokens for TypeParen[src]
    Auto Trait Implementations
    Blanket Implementations
    impl<T> Any for T where
        T: 'static + ?Sized,     [src]
    impl<T> Borrow<T> for T where
        T: ?Sized,     [src]
    impl<T> BorrowMut<T> for T where
        T: ?Sized,     [src]
    impl<T> From<T> for T[src]
    impl<T, U> Into<U> for T where
        U: From<T>,     [src]
    impl ToTokens for TypeParen[src]
    Auto Trait Implementations
    Blanket Implementations
    impl<T> Any for T where
        T: 'static + ?Sized,     [src]
    impl<T> Borrow<T> for T where
        T: ?Sized,     [src]
    impl<T> BorrowMut<T> for T where
        T: ?Sized,     [src]
    impl<T> From<T> for T[src]
    impl<T, U> Into<U> for T where
        U: From<T>,     [src]
    impl<T> Spanned for T where
        T: Spanned + ?Sized,     [src]
    impl<T> ToOwned for T where
        T: Clone,     [src]
    type Owned = T
    The resulting type after obtaining ownership.
    
-
    impl<T> ToOwned for T where
        T: Clone,     [src]
    type Owned = T
    The resulting type after obtaining ownership.
    
+
    impl<T, U> TryFrom<U> for T where
        U: Into<T>,     [src]
    type Error = Infallible
    The type returned in the event of a conversion error.
    
-
    impl<T, U> TryInto<U> for T where
        U: TryFrom<T>,     [src]
    type Error = <U as TryFrom<T>>::Error
    The type returned in the event of a conversion error.
    
-
    
\ No newline at end of file
+

    impl<T, U> TryFrom<U> for T where
        U: Into<T>,     [src]

    type Error = Infallible

    The type returned in the event of a conversion error.

    +

    impl<T, U> TryInto<U> for T where
        U: TryFrom<T>,     [src]

    type Error = <U as TryFrom<T>>::Error

    The type returned in the event of a conversion error.

    +
    + \ No newline at end of file diff --git a/syn/struct.TypePath.html b/syn/struct.TypePath.html index 6f0fccd..e3f7599 100644 --- a/syn/struct.TypePath.html +++ b/syn/struct.TypePath.html @@ -1,7 +1,7 @@ -syn::TypePath - Rust +syn::TypePath - Rust -

    [−][src]Struct syn::TypePath

    pub struct TypePath {
+
    Struct syn::TypePath[−][src]
    pub struct TypePath {
     pub qself: Option<QSelf>,
     pub path: Path,
 }
    A path like std::slice::Iter, optionally qualified with a
@@ -10,30 +10,31 @@ self-type as in <Vec<T> as SomeTrait>::Associated.
    
 "full" feature.
    
 
    
                        Fields
    qself: Option<QSelf>path: Path
    Trait Implementations
    impl Clone for TypePath[src]
    impl Debug for TypePath[src]
    impl Eq for TypePath[src]
    impl From<TypePath> for Type[src]
    impl Hash for TypePath[src]
    impl Parse for TypePath[src]
    impl PartialEq<TypePath> for TypePath[src]
    impl Parse for TypePath[src]
    impl PartialEq<TypePath> for TypePath[src]
    impl ToTokens for TypePath[src]
    Auto Trait Implementations
    Blanket Implementations
    impl<T> Any for T where
        T: 'static + ?Sized,     [src]
    impl<T> Borrow<T> for T where
        T: ?Sized,     [src]
    impl<T> BorrowMut<T> for T where
        T: ?Sized,     [src]
    impl<T> From<T> for T[src]
    impl<T, U> Into<U> for T where
        U: From<T>,     [src]
    impl ToTokens for TypePath[src]
    Auto Trait Implementations
    impl RefUnwindSafe for TypePath
    impl !Send for TypePath
    impl !Sync for TypePath
    impl Unpin for TypePath
    impl UnwindSafe for TypePath
    Blanket Implementations
    impl<T> Any for T where
        T: 'static + ?Sized,     [src]
    impl<T> Borrow<T> for T where
        T: ?Sized,     [src]
    impl<T> BorrowMut<T> for T where
        T: ?Sized,     [src]
    impl<T> From<T> for T[src]
    impl<T, U> Into<U> for T where
        U: From<T>,     [src]
    impl<T> Spanned for T where
        T: Spanned + ?Sized,     [src]
    impl<T> ToOwned for T where
        T: Clone,     [src]
    type Owned = T
    The resulting type after obtaining ownership.
    
-
    impl<T> ToOwned for T where
        T: Clone,     [src]
    type Owned = T
    The resulting type after obtaining ownership.
    
+
    impl<T, U> TryFrom<U> for T where
        U: Into<T>,     [src]
    type Error = Infallible
    The type returned in the event of a conversion error.
    
-
    impl<T, U> TryInto<U> for T where
        U: TryFrom<T>,     [src]
    type Error = <U as TryFrom<T>>::Error
    The type returned in the event of a conversion error.
    
-
    
\ No newline at end of file
+

    impl<T, U> TryFrom<U> for T where
        U: Into<T>,     [src]

    type Error = Infallible

    The type returned in the event of a conversion error.

    +

    impl<T, U> TryInto<U> for T where
        U: TryFrom<T>,     [src]

    type Error = <U as TryFrom<T>>::Error

    The type returned in the event of a conversion error.

    +
    + \ No newline at end of file diff --git a/syn/struct.TypePtr.html b/syn/struct.TypePtr.html index c1871d5..7764677 100644 --- a/syn/struct.TypePtr.html +++ b/syn/struct.TypePtr.html @@ -1,7 +1,7 @@ -syn::TypePtr - Rust +syn::TypePtr - Rust -

    [−][src]Struct syn::TypePtr

    pub struct TypePtr {
+
    Struct syn::TypePtr[−][src]
    pub struct TypePtr {
     pub star_token: Star,
     pub const_token: Option<Const>,
     pub mutability: Option<Mut>,
@@ -11,30 +11,31 @@
 "full" feature.
    
 
    
                        Fields
    star_token: Starconst_token: Option<Const>mutability: Option<Mut>elem: Box<Type>
    Trait Implementations
    impl Clone for TypePtr[src]
    impl Debug for TypePtr[src]
    impl Eq for TypePtr[src]
    impl From<TypePtr> for Type[src]
    impl Hash for TypePtr[src]
    impl Parse for TypePtr[src]
    impl PartialEq<TypePtr> for TypePtr[src]
    impl Parse for TypePtr[src]
    impl PartialEq<TypePtr> for TypePtr[src]
    impl ToTokens for TypePtr[src]
    Auto Trait Implementations
    Blanket Implementations
    impl<T> Any for T where
        T: 'static + ?Sized,     [src]
    impl<T> Borrow<T> for T where
        T: ?Sized,     [src]
    impl<T> BorrowMut<T> for T where
        T: ?Sized,     [src]
    impl<T> From<T> for T[src]
    impl<T, U> Into<U> for T where
        U: From<T>,     [src]
    impl ToTokens for TypePtr[src]
    Auto Trait Implementations
    impl RefUnwindSafe for TypePtr
    impl !Send for TypePtr
    impl !Sync for TypePtr
    impl Unpin for TypePtr
    impl UnwindSafe for TypePtr
    Blanket Implementations
    impl<T> Any for T where
        T: 'static + ?Sized,     [src]
    impl<T> Borrow<T> for T where
        T: ?Sized,     [src]
    impl<T> BorrowMut<T> for T where
        T: ?Sized,     [src]
    impl<T> From<T> for T[src]
    impl<T, U> Into<U> for T where
        U: From<T>,     [src]
    impl<T> Spanned for T where
        T: Spanned + ?Sized,     [src]
    impl<T> ToOwned for T where
        T: Clone,     [src]
    type Owned = T
    The resulting type after obtaining ownership.
    
-
    impl<T> ToOwned for T where
        T: Clone,     [src]
    type Owned = T
    The resulting type after obtaining ownership.
    
+
    impl<T, U> TryFrom<U> for T where
        U: Into<T>,     [src]
    type Error = Infallible
    The type returned in the event of a conversion error.
    
-
    impl<T, U> TryInto<U> for T where
        U: TryFrom<T>,     [src]
    type Error = <U as TryFrom<T>>::Error
    The type returned in the event of a conversion error.
    
-
    
\ No newline at end of file
+

    impl<T, U> TryFrom<U> for T where
        U: Into<T>,     [src]

    type Error = Infallible

    The type returned in the event of a conversion error.

    +

    impl<T, U> TryInto<U> for T where
        U: TryFrom<T>,     [src]

    type Error = <U as TryFrom<T>>::Error

    The type returned in the event of a conversion error.

    +
    + \ No newline at end of file diff --git a/syn/struct.TypeReference.html b/syn/struct.TypeReference.html index 7fc99fa..fcd59d2 100644 --- a/syn/struct.TypeReference.html +++ b/syn/struct.TypeReference.html @@ -1,7 +1,7 @@ -syn::TypeReference - Rust +syn::TypeReference - Rust -

    [−][src]Struct syn::TypeReference

    pub struct TypeReference {
+
    Struct syn::TypeReference[−][src]
    pub struct TypeReference {
     pub and_token: And,
     pub lifetime: Option<Lifetime>,
     pub mutability: Option<Mut>,
@@ -11,30 +11,31 @@
 "full" feature.
    
 
    
                        Fields
    and_token: Andlifetime: Option<Lifetime>mutability: Option<Mut>elem: Box<Type>
    Trait Implementations
    impl Clone for TypeReference[src]
    impl Debug for TypeReference[src]
    impl Eq for TypeReference[src]
    impl From<TypeReference> for Type[src]
    impl Hash for TypeReference[src]
    impl Parse for TypeReference[src]
    impl PartialEq<TypeReference> for TypeReference[src]
    impl Parse for TypeReference[src]
    impl PartialEq<TypeReference> for TypeReference[src]
    impl ToTokens for TypeReference[src]
    Auto Trait Implementations
    Blanket Implementations
    impl<T> Any for T where
        T: 'static + ?Sized,     [src]
    impl<T> Borrow<T> for T where
        T: ?Sized,     [src]
    impl<T> BorrowMut<T> for T where
        T: ?Sized,     [src]
    impl<T> From<T> for T[src]
    impl<T, U> Into<U> for T where
        U: From<T>,     [src]
    impl ToTokens for TypeReference[src]
    Auto Trait Implementations
    Blanket Implementations
    impl<T> Any for T where
        T: 'static + ?Sized,     [src]
    impl<T> Borrow<T> for T where
        T: ?Sized,     [src]
    impl<T> BorrowMut<T> for T where
        T: ?Sized,     [src]
    impl<T> From<T> for T[src]
    impl<T, U> Into<U> for T where
        U: From<T>,     [src]
    impl<T> Spanned for T where
        T: Spanned + ?Sized,     [src]
    impl<T> ToOwned for T where
        T: Clone,     [src]
    type Owned = T
    The resulting type after obtaining ownership.
    
-
    impl<T> ToOwned for T where
        T: Clone,     [src]
    type Owned = T
    The resulting type after obtaining ownership.
    
+
    impl<T, U> TryFrom<U> for T where
        U: Into<T>,     [src]
    type Error = Infallible
    The type returned in the event of a conversion error.
    
-
    impl<T, U> TryInto<U> for T where
        U: TryFrom<T>,     [src]
    type Error = <U as TryFrom<T>>::Error
    The type returned in the event of a conversion error.
    
-
    
\ No newline at end of file
+

    impl<T, U> TryFrom<U> for T where
        U: Into<T>,     [src]

    type Error = Infallible

    The type returned in the event of a conversion error.

    +

    impl<T, U> TryInto<U> for T where
        U: TryFrom<T>,     [src]

    type Error = <U as TryFrom<T>>::Error

    The type returned in the event of a conversion error.

    +
    + \ No newline at end of file diff --git a/syn/struct.TypeSlice.html b/syn/struct.TypeSlice.html index ade356a..15a04de 100644 --- a/syn/struct.TypeSlice.html +++ b/syn/struct.TypeSlice.html @@ -1,7 +1,7 @@ -syn::TypeSlice - Rust +syn::TypeSlice - Rust -

    [−][src]Struct syn::TypeSlice

    pub struct TypeSlice {
+
    Struct syn::TypeSlice[−][src]
    pub struct TypeSlice {
     pub bracket_token: Bracket,
     pub elem: Box<Type>,
 }
    A dynamically sized slice type: [T].
    
@@ -9,30 +9,31 @@
 "full" feature.
    
 
    
                        Fields
    bracket_token: Bracketelem: Box<Type>
    Trait Implementations
    impl Clone for TypeSlice[src]
    impl Debug for TypeSlice[src]
    impl Eq for TypeSlice[src]
    impl From<TypeSlice> for Type[src]
    impl Hash for TypeSlice[src]
    impl Parse for TypeSlice[src]
    impl PartialEq<TypeSlice> for TypeSlice[src]
    impl Parse for TypeSlice[src]
    impl PartialEq<TypeSlice> for TypeSlice[src]
    impl ToTokens for TypeSlice[src]
    Auto Trait Implementations
    Blanket Implementations
    impl<T> Any for T where
        T: 'static + ?Sized,     [src]
    impl<T> Borrow<T> for T where
        T: ?Sized,     [src]
    impl<T> BorrowMut<T> for T where
        T: ?Sized,     [src]
    impl<T> From<T> for T[src]
    impl<T, U> Into<U> for T where
        U: From<T>,     [src]
    impl ToTokens for TypeSlice[src]
    Auto Trait Implementations
    Blanket Implementations
    impl<T> Any for T where
        T: 'static + ?Sized,     [src]
    impl<T> Borrow<T> for T where
        T: ?Sized,     [src]
    impl<T> BorrowMut<T> for T where
        T: ?Sized,     [src]
    impl<T> From<T> for T[src]
    impl<T, U> Into<U> for T where
        U: From<T>,     [src]
    impl<T> Spanned for T where
        T: Spanned + ?Sized,     [src]
    impl<T> ToOwned for T where
        T: Clone,     [src]
    type Owned = T
    The resulting type after obtaining ownership.
    
-
    impl<T> ToOwned for T where
        T: Clone,     [src]
    type Owned = T
    The resulting type after obtaining ownership.
    
+
    impl<T, U> TryFrom<U> for T where
        U: Into<T>,     [src]
    type Error = Infallible
    The type returned in the event of a conversion error.
    
-
    impl<T, U> TryInto<U> for T where
        U: TryFrom<T>,     [src]
    type Error = <U as TryFrom<T>>::Error
    The type returned in the event of a conversion error.
    
-
    
\ No newline at end of file
+

    impl<T, U> TryFrom<U> for T where
        U: Into<T>,     [src]

    type Error = Infallible

    The type returned in the event of a conversion error.

    +

    impl<T, U> TryInto<U> for T where
        U: TryFrom<T>,     [src]

    type Error = <U as TryFrom<T>>::Error

    The type returned in the event of a conversion error.

    +
    + \ No newline at end of file diff --git a/syn/struct.TypeTraitObject.html b/syn/struct.TypeTraitObject.html index 1718651..52f489b 100644 --- a/syn/struct.TypeTraitObject.html +++ b/syn/struct.TypeTraitObject.html @@ -1,7 +1,7 @@ -syn::TypeTraitObject - Rust +syn::TypeTraitObject - Rust -

    [−][src]Struct syn::TypeTraitObject

    pub struct TypeTraitObject {
+
    Struct syn::TypeTraitObject[−][src]
    pub struct TypeTraitObject {
     pub dyn_token: Option<Dyn>,
     pub bounds: Punctuated<TypeParamBound, Add>,
 }
    A trait object type Bound1 + Bound2 + Bound3 where Bound is a
@@ -9,31 +9,32 @@ trait or a lifetime.
    
 
    This type is available only if Syn is built with the "derive" or
 "full" feature.
    
 
    
-                       Fields
    dyn_token: Option<Dyn>bounds: Punctuated<TypeParamBound, Add>
    Implementations
    impl TypeTraitObject[src]
    pub fn without_plus(input: ParseStream<'_>) -> Result<Self>[src]
    Trait Implementations
    impl Clone for TypeTraitObject[src]
    
\ No newline at end of file
+

    impl<T, U> TryFrom<U> for T where
        U: Into<T>,     [src]

    type Error = Infallible

    The type returned in the event of a conversion error.

    +

    impl<T, U> TryInto<U> for T where
        U: TryFrom<T>,     [src]

    type Error = <U as TryFrom<T>>::Error

    The type returned in the event of a conversion error.

    +
    + \ No newline at end of file diff --git a/syn/struct.TypeTuple.html b/syn/struct.TypeTuple.html index 20f615e..1d70c06 100644 --- a/syn/struct.TypeTuple.html +++ b/syn/struct.TypeTuple.html @@ -1,7 +1,7 @@ -syn::TypeTuple - Rust +syn::TypeTuple - Rust -

    [−][src]Struct syn::TypeTuple

    pub struct TypeTuple {
+
    Struct syn::TypeTuple[−][src]
    pub struct TypeTuple {
     pub paren_token: Paren,
     pub elems: Punctuated<Type, Comma>,
 }
    A tuple type: (A, B, C, String).
    
@@ -9,30 +9,31 @@
 "full" feature.
    
 
    
                        Fields
    paren_token: Parenelems: Punctuated<Type, Comma>
    Trait Implementations
    impl Clone for TypeTuple[src]
    impl Debug for TypeTuple[src]
    impl Eq for TypeTuple[src]
    impl From<TypeTuple> for Type[src]
    impl Hash for TypeTuple[src]
    impl Parse for TypeTuple[src]
    impl PartialEq<TypeTuple> for TypeTuple[src]
    impl Parse for TypeTuple[src]
    impl PartialEq<TypeTuple> for TypeTuple[src]
    impl ToTokens for TypeTuple[src]
    Auto Trait Implementations
    Blanket Implementations
    impl<T> Any for T where
        T: 'static + ?Sized,     [src]
    impl<T> Borrow<T> for T where
        T: ?Sized,     [src]
    impl<T> BorrowMut<T> for T where
        T: ?Sized,     [src]
    impl<T> From<T> for T[src]
    impl<T, U> Into<U> for T where
        U: From<T>,     [src]
    impl ToTokens for TypeTuple[src]
    Auto Trait Implementations
    Blanket Implementations
    impl<T> Any for T where
        T: 'static + ?Sized,     [src]
    impl<T> Borrow<T> for T where
        T: ?Sized,     [src]
    impl<T> BorrowMut<T> for T where
        T: ?Sized,     [src]
    impl<T> From<T> for T[src]
    impl<T, U> Into<U> for T where
        U: From<T>,     [src]
    impl<T> Spanned for T where
        T: Spanned + ?Sized,     [src]
    impl<T> ToOwned for T where
        T: Clone,     [src]
    type Owned = T
    The resulting type after obtaining ownership.
    
-
    impl<T> ToOwned for T where
        T: Clone,     [src]
    type Owned = T
    The resulting type after obtaining ownership.
    
+
    impl<T, U> TryFrom<U> for T where
        U: Into<T>,     [src]
    type Error = Infallible
    The type returned in the event of a conversion error.
    
-
    impl<T, U> TryInto<U> for T where
        U: TryFrom<T>,     [src]
    type Error = <U as TryFrom<T>>::Error
    The type returned in the event of a conversion error.
    
-
    
\ No newline at end of file
+

    impl<T, U> TryFrom<U> for T where
        U: Into<T>,     [src]

    type Error = Infallible

    The type returned in the event of a conversion error.

    +

    impl<T, U> TryInto<U> for T where
        U: TryFrom<T>,     [src]

    type Error = <U as TryFrom<T>>::Error

    The type returned in the event of a conversion error.

    +
    + \ No newline at end of file diff --git a/syn/struct.Variadic.html b/syn/struct.Variadic.html index 88b1a7c..5a2eaa8 100644 --- a/syn/struct.Variadic.html +++ b/syn/struct.Variadic.html @@ -1,7 +1,7 @@ -syn::Variadic - Rust +syn::Variadic - Rust -

    [−][src]Struct syn::Variadic

    pub struct Variadic {
+
    Struct syn::Variadic[−][src]
    pub struct Variadic {
     pub attrs: Vec<Attribute>,
     pub dots: Dot3,
 }
    The variadic argument of a foreign function.
    
@@ -15,29 +15,30 @@
 feature.
    
 
    
                        Fields
    attrs: Vec<Attribute>dots: Dot3
    Trait Implementations
    impl Clone for Variadic[src]
    impl Debug for Variadic[src]
    impl Eq for Variadic[src]
    impl Hash for Variadic[src]
    impl PartialEq<Variadic> for Variadic[src]
    impl ToTokens for Variadic[src]
    Auto Trait Implementations
    Blanket Implementations
    impl<T> Any for T where
        T: 'static + ?Sized,     [src]
    impl<T> Borrow<T> for T where
        T: ?Sized,     [src]
    impl<T> BorrowMut<T> for T where
        T: ?Sized,     [src]
    impl<T> From<T> for T[src]
    impl<T, U> Into<U> for T where
        U: From<T>,     [src]
    impl ToTokens for Variadic[src]
    Auto Trait Implementations
    impl RefUnwindSafe for Variadic
    impl !Send for Variadic
    impl !Sync for Variadic
    impl Unpin for Variadic
    impl UnwindSafe for Variadic
    Blanket Implementations
    impl<T> Any for T where
        T: 'static + ?Sized,     [src]
    impl<T> Borrow<T> for T where
        T: ?Sized,     [src]
    impl<T> BorrowMut<T> for T where
        T: ?Sized,     [src]
    impl<T> From<T> for T[src]
    impl<T, U> Into<U> for T where
        U: From<T>,     [src]
    impl<T> Spanned for T where
        T: Spanned + ?Sized,     [src]
    impl<T> ToOwned for T where
        T: Clone,     [src]
    type Owned = T
    The resulting type after obtaining ownership.
    
-
    impl<T> ToOwned for T where
        T: Clone,     [src]
    type Owned = T
    The resulting type after obtaining ownership.
    
+
    impl<T, U> TryFrom<U> for T where
        U: Into<T>,     [src]
    type Error = Infallible
    The type returned in the event of a conversion error.
    
-
    impl<T, U> TryInto<U> for T where
        U: TryFrom<T>,     [src]
    type Error = <U as TryFrom<T>>::Error
    The type returned in the event of a conversion error.
    
-
    
\ No newline at end of file
+

    impl<T, U> TryFrom<U> for T where
        U: Into<T>,     [src]

    type Error = Infallible

    The type returned in the event of a conversion error.

    +

    impl<T, U> TryInto<U> for T where
        U: TryFrom<T>,     [src]

    type Error = <U as TryFrom<T>>::Error

    The type returned in the event of a conversion error.

    +
    + \ No newline at end of file diff --git a/syn/struct.Variant.html b/syn/struct.Variant.html index 2592e19..1c3c9ae 100644 --- a/syn/struct.Variant.html +++ b/syn/struct.Variant.html @@ -1,7 +1,7 @@ -syn::Variant - Rust +syn::Variant - Rust -

    [−][src]Struct syn::Variant

    pub struct Variant {
+
    Struct syn::Variant[−][src]
    pub struct Variant {
     pub attrs: Vec<Attribute>,
     pub ident: Ident,
     pub fields: Fields,
@@ -15,29 +15,30 @@ feature.
    
 
    fields: Fields
    Content stored in the variant.
    
 
    discriminant: Option<(Eq, Expr)>
    Explicit discriminant: Variant = 1
    
 
    Trait Implementations
    impl Clone for Variant[src]
    impl Debug for Variant[src]
    impl Eq for Variant[src]
    impl Hash for Variant[src]
    impl Parse for Variant[src]
    impl PartialEq<Variant> for Variant[src]
    impl ToTokens for Variant[src]
    Auto Trait Implementations
    Blanket Implementations
    impl<T> Any for T where
        T: 'static + ?Sized,     [src]
    impl<T> Borrow<T> for T where
        T: ?Sized,     [src]
    impl<T> BorrowMut<T> for T where
        T: ?Sized,     [src]
    impl<T> From<T> for T[src]
    impl<T, U> Into<U> for T where
        U: From<T>,     [src]
    impl ToTokens for Variant[src]
    Auto Trait Implementations
    impl RefUnwindSafe for Variant
    impl !Send for Variant
    impl !Sync for Variant
    impl Unpin for Variant
    impl UnwindSafe for Variant
    Blanket Implementations
    impl<T> Any for T where
        T: 'static + ?Sized,     [src]
    impl<T> Borrow<T> for T where
        T: ?Sized,     [src]
    impl<T> BorrowMut<T> for T where
        T: ?Sized,     [src]
    impl<T> From<T> for T[src]
    impl<T, U> Into<U> for T where
        U: From<T>,     [src]
    impl<T> Spanned for T where
        T: Spanned + ?Sized,     [src]
    impl<T> ToOwned for T where
        T: Clone,     [src]
    type Owned = T
    The resulting type after obtaining ownership.
    
-
    impl<T> ToOwned for T where
        T: Clone,     [src]
    type Owned = T
    The resulting type after obtaining ownership.
    
+
    impl<T, U> TryFrom<U> for T where
        U: Into<T>,     [src]
    type Error = Infallible
    The type returned in the event of a conversion error.
    
-
    impl<T, U> TryInto<U> for T where
        U: TryFrom<T>,     [src]
    type Error = <U as TryFrom<T>>::Error
    The type returned in the event of a conversion error.
    
-
    
\ No newline at end of file
+

    impl<T, U> TryFrom<U> for T where
        U: Into<T>,     [src]

    type Error = Infallible

    The type returned in the event of a conversion error.

    +

    impl<T, U> TryInto<U> for T where
        U: TryFrom<T>,     [src]

    type Error = <U as TryFrom<T>>::Error

    The type returned in the event of a conversion error.

    +
    + \ No newline at end of file diff --git a/syn/struct.VisCrate.html b/syn/struct.VisCrate.html index 614b98a..134f698 100644 --- a/syn/struct.VisCrate.html +++ b/syn/struct.VisCrate.html @@ -1,37 +1,38 @@ -syn::VisCrate - Rust +syn::VisCrate - Rust -

    [−][src]Struct syn::VisCrate

    pub struct VisCrate {
+
    Struct syn::VisCrate[−][src]
    pub struct VisCrate {
     pub crate_token: Crate,
 }
    A crate-level visibility: crate.
    
 
    This type is available only if Syn is built with the "derive" or
 "full" feature.
    
 
    
                        Fields
    crate_token: Crate
    Trait Implementations
    impl Clone for VisCrate[src]
    impl Debug for VisCrate[src]
    impl Eq for VisCrate[src]
    impl From<VisCrate> for Visibility[src]
    impl Hash for VisCrate[src]
    impl PartialEq<VisCrate> for VisCrate[src]
    impl ToTokens for VisCrate[src]
    Auto Trait Implementations
    Blanket Implementations
    impl<T> Any for T where
        T: 'static + ?Sized,     [src]
    impl<T> Borrow<T> for T where
        T: ?Sized,     [src]
    impl<T> BorrowMut<T> for T where
        T: ?Sized,     [src]
    impl<T> From<T> for T[src]
    impl<T, U> Into<U> for T where
        U: From<T>,     [src]
    impl ToTokens for VisCrate[src]
    Auto Trait Implementations
    impl RefUnwindSafe for VisCrate
    impl !Send for VisCrate
    impl !Sync for VisCrate
    impl Unpin for VisCrate
    impl UnwindSafe for VisCrate
    Blanket Implementations
    impl<T> Any for T where
        T: 'static + ?Sized,     [src]
    impl<T> Borrow<T> for T where
        T: ?Sized,     [src]
    impl<T> BorrowMut<T> for T where
        T: ?Sized,     [src]
    impl<T> From<T> for T[src]
    impl<T, U> Into<U> for T where
        U: From<T>,     [src]
    impl<T> Spanned for T where
        T: Spanned + ?Sized,     [src]
    impl<T> ToOwned for T where
        T: Clone,     [src]
    type Owned = T
    The resulting type after obtaining ownership.
    
-
    impl<T> ToOwned for T where
        T: Clone,     [src]
    type Owned = T
    The resulting type after obtaining ownership.
    
+
    impl<T, U> TryFrom<U> for T where
        U: Into<T>,     [src]
    type Error = Infallible
    The type returned in the event of a conversion error.
    
-
    impl<T, U> TryInto<U> for T where
        U: TryFrom<T>,     [src]
    type Error = <U as TryFrom<T>>::Error
    The type returned in the event of a conversion error.
    
-
    
\ No newline at end of file
+

    impl<T, U> TryFrom<U> for T where
        U: Into<T>,     [src]

    type Error = Infallible

    The type returned in the event of a conversion error.

    +

    impl<T, U> TryInto<U> for T where
        U: TryFrom<T>,     [src]

    type Error = <U as TryFrom<T>>::Error

    The type returned in the event of a conversion error.

    +
    + \ No newline at end of file diff --git a/syn/struct.VisPublic.html b/syn/struct.VisPublic.html index 717fbb3..5d9c89c 100644 --- a/syn/struct.VisPublic.html +++ b/syn/struct.VisPublic.html @@ -1,37 +1,38 @@ -syn::VisPublic - Rust +syn::VisPublic - Rust -

    [−][src]Struct syn::VisPublic

    pub struct VisPublic {
+
    Struct syn::VisPublic[−][src]
    pub struct VisPublic {
     pub pub_token: Pub,
 }
    A public visibility level: pub.
    
 
    This type is available only if Syn is built with the "derive" or
 "full" feature.
    
 
    
                        Fields
    pub_token: Pub
    Trait Implementations
    impl Clone for VisPublic[src]
    impl Debug for VisPublic[src]
    impl Eq for VisPublic[src]
    impl From<VisPublic> for Visibility[src]
    impl Hash for VisPublic[src]
    impl PartialEq<VisPublic> for VisPublic[src]
    impl ToTokens for VisPublic[src]
    Auto Trait Implementations
    Blanket Implementations
    impl<T> Any for T where
        T: 'static + ?Sized,     [src]
    impl<T> Borrow<T> for T where
        T: ?Sized,     [src]
    impl<T> BorrowMut<T> for T where
        T: ?Sized,     [src]
    impl<T> From<T> for T[src]
    impl<T, U> Into<U> for T where
        U: From<T>,     [src]
    impl ToTokens for VisPublic[src]
    Auto Trait Implementations
    Blanket Implementations
    impl<T> Any for T where
        T: 'static + ?Sized,     [src]
    impl<T> Borrow<T> for T where
        T: ?Sized,     [src]
    impl<T> BorrowMut<T> for T where
        T: ?Sized,     [src]
    impl<T> From<T> for T[src]
    impl<T, U> Into<U> for T where
        U: From<T>,     [src]
    impl<T> Spanned for T where
        T: Spanned + ?Sized,     [src]
    impl<T> ToOwned for T where
        T: Clone,     [src]
    type Owned = T
    The resulting type after obtaining ownership.
    
-
    impl<T> ToOwned for T where
        T: Clone,     [src]
    type Owned = T
    The resulting type after obtaining ownership.
    
+
    impl<T, U> TryFrom<U> for T where
        U: Into<T>,     [src]
    type Error = Infallible
    The type returned in the event of a conversion error.
    
-
    impl<T, U> TryInto<U> for T where
        U: TryFrom<T>,     [src]
    type Error = <U as TryFrom<T>>::Error
    The type returned in the event of a conversion error.
    
-
    
\ No newline at end of file
+

    impl<T, U> TryFrom<U> for T where
        U: Into<T>,     [src]

    type Error = Infallible

    The type returned in the event of a conversion error.

    +

    impl<T, U> TryInto<U> for T where
        U: TryFrom<T>,     [src]

    type Error = <U as TryFrom<T>>::Error

    The type returned in the event of a conversion error.

    +
    + \ No newline at end of file diff --git a/syn/struct.VisRestricted.html b/syn/struct.VisRestricted.html index ba09e11..6d59080 100644 --- a/syn/struct.VisRestricted.html +++ b/syn/struct.VisRestricted.html @@ -1,7 +1,7 @@ -syn::VisRestricted - Rust +syn::VisRestricted - Rust -

    [−][src]Struct syn::VisRestricted

    pub struct VisRestricted {
+
    Struct syn::VisRestricted[−][src]
    pub struct VisRestricted {
     pub pub_token: Pub,
     pub paren_token: Paren,
     pub in_token: Option<In>,
@@ -12,30 +12,31 @@
 "full" feature.
    
 
    
                        Fields
    pub_token: Pubparen_token: Parenin_token: Option<In>path: Box<Path>
    Trait Implementations
    impl Clone for VisRestricted[src]
    impl Debug for VisRestricted[src]
    impl Eq for VisRestricted[src]
    impl From<VisRestricted> for Visibility[src]
    impl Hash for VisRestricted[src]
    impl PartialEq<VisRestricted> for VisRestricted[src]
    impl ToTokens for VisRestricted[src]
    Auto Trait Implementations
    Blanket Implementations
    impl<T> Any for T where
        T: 'static + ?Sized,     [src]
    impl<T> Borrow<T> for T where
        T: ?Sized,     [src]
    impl<T> BorrowMut<T> for T where
        T: ?Sized,     [src]
    impl<T> From<T> for T[src]
    impl<T, U> Into<U> for T where
        U: From<T>,     [src]
    impl ToTokens for VisRestricted[src]
    Auto Trait Implementations
    Blanket Implementations
    impl<T> Any for T where
        T: 'static + ?Sized,     [src]
    impl<T> Borrow<T> for T where
        T: ?Sized,     [src]
    impl<T> BorrowMut<T> for T where
        T: ?Sized,     [src]
    impl<T> From<T> for T[src]
    impl<T, U> Into<U> for T where
        U: From<T>,     [src]
    impl<T> Spanned for T where
        T: Spanned + ?Sized,     [src]
    impl<T> ToOwned for T where
        T: Clone,     [src]
    type Owned = T
    The resulting type after obtaining ownership.
    
-
    impl<T> ToOwned for T where
        T: Clone,     [src]
    type Owned = T
    The resulting type after obtaining ownership.
    
+
    impl<T, U> TryFrom<U> for T where
        U: Into<T>,     [src]
    type Error = Infallible
    The type returned in the event of a conversion error.
    
-
    impl<T, U> TryInto<U> for T where
        U: TryFrom<T>,     [src]
    type Error = <U as TryFrom<T>>::Error
    The type returned in the event of a conversion error.
    
-
    
\ No newline at end of file
+

    impl<T, U> TryFrom<U> for T where
        U: Into<T>,     [src]

    type Error = Infallible

    The type returned in the event of a conversion error.

    +

    impl<T, U> TryInto<U> for T where
        U: TryFrom<T>,     [src]

    type Error = <U as TryFrom<T>>::Error

    The type returned in the event of a conversion error.

    +
    + \ No newline at end of file diff --git a/syn/struct.WhereClause.html b/syn/struct.WhereClause.html index 1dc0d2a..c5ce0ae 100644 --- a/syn/struct.WhereClause.html +++ b/syn/struct.WhereClause.html @@ -1,7 +1,7 @@ -syn::WhereClause - Rust +syn::WhereClause - Rust -

    [−][src]Struct syn::WhereClause

    pub struct WhereClause {
+
    Struct syn::WhereClause[−][src]
    pub struct WhereClause {
     pub where_token: Where,
     pub predicates: Punctuated<WherePredicate, Comma>,
 }
    A where clause in a definition: where T: Deserialize<'de>, D: 'static.
    
@@ -9,29 +9,30 @@
 feature.
    
 
    
                        Fields
    where_token: Wherepredicates: Punctuated<WherePredicate, Comma>
    Trait Implementations
    impl Clone for WhereClause[src]
    impl Debug for WhereClause[src]
    impl Eq for WhereClause[src]
    impl Hash for WhereClause[src]
    impl Parse for WhereClause[src]
    impl PartialEq<WhereClause> for WhereClause[src]
    impl Parse for WhereClause[src]
    impl PartialEq<WhereClause> for WhereClause[src]
    impl ToTokens for WhereClause[src]
    Auto Trait Implementations
    Blanket Implementations
    impl<T> Any for T where
        T: 'static + ?Sized,     [src]
    impl<T> Borrow<T> for T where
        T: ?Sized,     [src]
    impl<T> BorrowMut<T> for T where
        T: ?Sized,     [src]
    impl<T> From<T> for T[src]
    impl<T, U> Into<U> for T where
        U: From<T>,     [src]
    impl ToTokens for WhereClause[src]
    Auto Trait Implementations
    Blanket Implementations
    impl<T> Any for T where
        T: 'static + ?Sized,     [src]
    impl<T> Borrow<T> for T where
        T: ?Sized,     [src]
    impl<T> BorrowMut<T> for T where
        T: ?Sized,     [src]
    impl<T> From<T> for T[src]
    impl<T, U> Into<U> for T where
        U: From<T>,     [src]
    impl<T> Spanned for T where
        T: Spanned + ?Sized,     [src]
    impl<T> ToOwned for T where
        T: Clone,     [src]
    type Owned = T
    The resulting type after obtaining ownership.
    
-
    impl<T> ToOwned for T where
        T: Clone,     [src]
    type Owned = T
    The resulting type after obtaining ownership.
    
+
    impl<T, U> TryFrom<U> for T where
        U: Into<T>,     [src]
    type Error = Infallible
    The type returned in the event of a conversion error.
    
-
    impl<T, U> TryInto<U> for T where
        U: TryFrom<T>,     [src]
    type Error = <U as TryFrom<T>>::Error
    The type returned in the event of a conversion error.
    
-
    
\ No newline at end of file
+

    impl<T, U> TryFrom<U> for T where
        U: Into<T>,     [src]

    type Error = Infallible

    The type returned in the event of a conversion error.

    +

    impl<T, U> TryInto<U> for T where
        U: TryFrom<T>,     [src]

    type Error = <U as TryFrom<T>>::Error

    The type returned in the event of a conversion error.

    +
    + \ No newline at end of file diff --git a/syn/token/index.html b/syn/token/index.html index e0bad4c..27414ff 100644 --- a/syn/token/index.html +++ b/syn/token/index.html @@ -1,7 +1,7 @@ -syn::token - Rust +syn::token - Rust -

    [−][src]Module syn::token

    Tokens representing Rust punctuation, keywords, and delimiters.

    +

    Module syn::token[−][src]

    Tokens representing Rust punctuation, keywords, and delimiters.

    The type names in this module can be difficult to keep straight, so we prefer to use the Token! macro instead. This is a type-macro that expands to the token type of the given token.

    @@ -172,4 +172,5 @@ method. Delimiter tokens are parsed using the Yield

    yield

    Traits

    Token

    Marker trait for types that represent single tokens.

    -
    \ No newline at end of file +
    + \ No newline at end of file diff --git a/syn/token/struct.Abstract.html b/syn/token/struct.Abstract.html index d9888fc..a0be594 100644 --- a/syn/token/struct.Abstract.html +++ b/syn/token/struct.Abstract.html @@ -1,37 +1,38 @@ -syn::token::Abstract - Rust +syn::token::Abstract - Rust -

    [−][src]Struct syn::token::Abstract

    pub struct Abstract {
+
    Struct syn::token::Abstract[−][src]
    pub struct Abstract {
     pub span: Span,
 }
    abstract
    
-
    Don't try to remember the name of this type — use the
+
    Don’t try to remember the name of this type — use the
 Token! macro instead.
    
 
    
                        Fields
    span: Span
    Trait Implementations
    impl Clone for Abstract[src]
    impl Copy for Abstract[src]
    impl Debug for Abstract[src]
    impl Default for Abstract[src]
    impl Default for Abstract[src]
    impl Eq for Abstract[src]
    impl Hash for Abstract[src]
    impl Parse for Abstract[src]
    impl PartialEq<Abstract> for Abstract[src]
    impl ToTokens for Abstract[src]
    impl Token for Abstract[src]
    Auto Trait Implementations
    Blanket Implementations
    impl<T> Any for T where
        T: 'static + ?Sized,     [src]
    impl<T> Borrow<T> for T where
        T: ?Sized,     [src]
    impl<T> BorrowMut<T> for T where
        T: ?Sized,     [src]
    impl<T> From<T> for T[src]
    impl<T, U> Into<U> for T where
        U: From<T>,     [src]
    impl Token for Abstract[src]
    Auto Trait Implementations
    impl RefUnwindSafe for Abstract
    impl !Send for Abstract
    impl !Sync for Abstract
    impl Unpin for Abstract
    impl UnwindSafe for Abstract
    Blanket Implementations
    impl<T> Any for T where
        T: 'static + ?Sized,     [src]
    impl<T> Borrow<T> for T where
        T: ?Sized,     [src]
    impl<T> BorrowMut<T> for T where
        T: ?Sized,     [src]
    impl<T> From<T> for T[src]
    impl<T, U> Into<U> for T where
        U: From<T>,     [src]
    impl<T> Spanned for T where
        T: Spanned + ?Sized,     [src]
    impl<T> ToOwned for T where
        T: Clone,     [src]
    type Owned = T
    The resulting type after obtaining ownership.
    
-
    impl<T> ToOwned for T where
        T: Clone,     [src]
    type Owned = T
    The resulting type after obtaining ownership.
    
+
    impl<T, U> TryFrom<U> for T where
        U: Into<T>,     [src]
    type Error = Infallible
    The type returned in the event of a conversion error.
    
-
    impl<T, U> TryInto<U> for T where
        U: TryFrom<T>,     [src]
    type Error = <U as TryFrom<T>>::Error
    The type returned in the event of a conversion error.
    
-
    
\ No newline at end of file
+

    impl<T, U> TryFrom<U> for T where
        U: Into<T>,     [src]

    type Error = Infallible

    The type returned in the event of a conversion error.

    +

    impl<T, U> TryInto<U> for T where
        U: TryFrom<T>,     [src]

    type Error = <U as TryFrom<T>>::Error

    The type returned in the event of a conversion error.

    +
    + \ No newline at end of file diff --git a/syn/token/struct.Add.html b/syn/token/struct.Add.html index a768db9..1cbd925 100644 --- a/syn/token/struct.Add.html +++ b/syn/token/struct.Add.html @@ -1,40 +1,41 @@ -syn::token::Add - Rust +syn::token::Add - Rust -

    [−][src]Struct syn::token::Add

    #[repr(C)]pub struct Add {
+
    Struct syn::token::Add[−][src]
    #[repr(C)]pub struct Add {
     pub spans: [Span; 1],
 }
    +
    
-
    Don't try to remember the name of this type — use the
+
    Don’t try to remember the name of this type — use the
 Token! macro instead.
    
 
    
                        Fields
    spans: [Span; 1]
    Trait Implementations
    impl Clone for Add[src]
    impl Copy for Add[src]
    impl Debug for Add[src]
    impl Default for Add[src]
    impl Default for Add[src]
    impl Deref for Add[src]
    type Target = WithSpan
    The resulting type after dereferencing.
    
 
    impl DerefMut for Add[src]
    impl Eq for Add[src]
    impl Hash for Add[src]
    impl Parse for Add[src]
    impl PartialEq<Add> for Add[src]
    impl ToTokens for Add[src]
    impl Token for Add[src]
    Auto Trait Implementations
    impl RefUnwindSafe for Add[src]
    impl !Send for Add[src]
    impl !Sync for Add[src]
    impl Unpin for Add[src]
    impl UnwindSafe for Add[src]
    Blanket Implementations
    impl<T> Any for T where
        T: 'static + ?Sized,     [src]
    impl<T> Borrow<T> for T where
        T: ?Sized,     [src]
    impl<T> BorrowMut<T> for T where
        T: ?Sized,     [src]
    impl<T> From<T> for T[src]
    impl<T, U> Into<U> for T where
        U: From<T>,     [src]
    impl Token for Add[src]
    Auto Trait Implementations
    impl RefUnwindSafe for Add
    impl !Send for Add
    impl !Sync for Add
    impl Unpin for Add
    impl UnwindSafe for Add
    Blanket Implementations
    impl<T> Any for T where
        T: 'static + ?Sized,     [src]
    impl<T> Borrow<T> for T where
        T: ?Sized,     [src]
    impl<T> BorrowMut<T> for T where
        T: ?Sized,     [src]
    impl<T> From<T> for T[src]
    impl<T, U> Into<U> for T where
        U: From<T>,     [src]
    impl<T> Spanned for T where
        T: Spanned + ?Sized,     [src]
    impl<T> ToOwned for T where
        T: Clone,     [src]
    type Owned = T
    The resulting type after obtaining ownership.
    
-
    impl<T> ToOwned for T where
        T: Clone,     [src]
    type Owned = T
    The resulting type after obtaining ownership.
    
+
    impl<T, U> TryFrom<U> for T where
        U: Into<T>,     [src]
    type Error = Infallible
    The type returned in the event of a conversion error.
    
-
    impl<T, U> TryInto<U> for T where
        U: TryFrom<T>,     [src]
    type Error = <U as TryFrom<T>>::Error
    The type returned in the event of a conversion error.
    
-
    
\ No newline at end of file
+

    impl<T, U> TryFrom<U> for T where
        U: Into<T>,     [src]

    type Error = Infallible

    The type returned in the event of a conversion error.

    +

    impl<T, U> TryInto<U> for T where
        U: TryFrom<T>,     [src]

    type Error = <U as TryFrom<T>>::Error

    The type returned in the event of a conversion error.

    +
    + \ No newline at end of file diff --git a/syn/token/struct.AddEq.html b/syn/token/struct.AddEq.html index fe95836..c293d44 100644 --- a/syn/token/struct.AddEq.html +++ b/syn/token/struct.AddEq.html @@ -1,37 +1,38 @@ -syn::token::AddEq - Rust +syn::token::AddEq - Rust -

    [−][src]Struct syn::token::AddEq

    #[repr(C)]pub struct AddEq {
+
    Struct syn::token::AddEq[−][src]
    #[repr(C)]pub struct AddEq {
     pub spans: [Span; 2],
 }
    +=
    
-
    Don't try to remember the name of this type — use the
+
    Don’t try to remember the name of this type — use the
 Token! macro instead.
    
 
    
                        Fields
    spans: [Span; 2]
    Trait Implementations
    impl Clone for AddEq[src]
    impl Copy for AddEq[src]
    impl Debug for AddEq[src]
    impl Default for AddEq[src]
    impl Default for AddEq[src]
    impl Eq for AddEq[src]
    impl Hash for AddEq[src]
    impl Parse for AddEq[src]
    impl PartialEq<AddEq> for AddEq[src]
    impl ToTokens for AddEq[src]
    impl Token for AddEq[src]
    Auto Trait Implementations
    Blanket Implementations
    impl<T> Any for T where
        T: 'static + ?Sized,     [src]
    impl<T> Borrow<T> for T where
        T: ?Sized,     [src]
    impl<T> BorrowMut<T> for T where
        T: ?Sized,     [src]
    impl<T> From<T> for T[src]
    impl<T, U> Into<U> for T where
        U: From<T>,     [src]
    impl Token for AddEq[src]
    Auto Trait Implementations
    impl RefUnwindSafe for AddEq
    impl !Send for AddEq
    impl !Sync for AddEq
    impl Unpin for AddEq
    impl UnwindSafe for AddEq
    Blanket Implementations
    impl<T> Any for T where
        T: 'static + ?Sized,     [src]
    impl<T> Borrow<T> for T where
        T: ?Sized,     [src]
    impl<T> BorrowMut<T> for T where
        T: ?Sized,     [src]
    impl<T> From<T> for T[src]
    impl<T, U> Into<U> for T where
        U: From<T>,     [src]
    impl<T> Spanned for T where
        T: Spanned + ?Sized,     [src]
    impl<T> ToOwned for T where
        T: Clone,     [src]
    type Owned = T
    The resulting type after obtaining ownership.
    
-
    impl<T> ToOwned for T where
        T: Clone,     [src]
    type Owned = T
    The resulting type after obtaining ownership.
    
+
    impl<T, U> TryFrom<U> for T where
        U: Into<T>,     [src]
    type Error = Infallible
    The type returned in the event of a conversion error.
    
-
    impl<T, U> TryInto<U> for T where
        U: TryFrom<T>,     [src]
    type Error = <U as TryFrom<T>>::Error
    The type returned in the event of a conversion error.
    
-
    
\ No newline at end of file
+

    impl<T, U> TryFrom<U> for T where
        U: Into<T>,     [src]

    type Error = Infallible

    The type returned in the event of a conversion error.

    +

    impl<T, U> TryInto<U> for T where
        U: TryFrom<T>,     [src]

    type Error = <U as TryFrom<T>>::Error

    The type returned in the event of a conversion error.

    +
    + \ No newline at end of file diff --git a/syn/token/struct.And.html b/syn/token/struct.And.html index 917daff..c7d21c0 100644 --- a/syn/token/struct.And.html +++ b/syn/token/struct.And.html @@ -1,40 +1,41 @@ -syn::token::And - Rust +syn::token::And - Rust -

    [−][src]Struct syn::token::And

    #[repr(C)]pub struct And {
+
    Struct syn::token::And[−][src]
    #[repr(C)]pub struct And {
     pub spans: [Span; 1],
 }
    &
    
-
    Don't try to remember the name of this type — use the
+
    Don’t try to remember the name of this type — use the
 Token! macro instead.
    
 
    
                        Fields
    spans: [Span; 1]
    Trait Implementations
    impl Clone for And[src]
    impl Copy for And[src]
    impl Debug for And[src]
    impl Default for And[src]
    impl Default for And[src]
    impl Deref for And[src]
    type Target = WithSpan
    The resulting type after dereferencing.
    
 
    impl DerefMut for And[src]
    impl Eq for And[src]
    impl Hash for And[src]
    impl Parse for And[src]
    impl PartialEq<And> for And[src]
    impl ToTokens for And[src]
    impl Token for And[src]
    Auto Trait Implementations
    impl RefUnwindSafe for And[src]
    impl !Send for And[src]
    impl !Sync for And[src]
    impl Unpin for And[src]
    impl UnwindSafe for And[src]
    Blanket Implementations
    impl<T> Any for T where
        T: 'static + ?Sized,     [src]
    impl<T> Borrow<T> for T where
        T: ?Sized,     [src]
    impl<T> BorrowMut<T> for T where
        T: ?Sized,     [src]
    impl<T> From<T> for T[src]
    impl<T, U> Into<U> for T where
        U: From<T>,     [src]
    impl Token for And[src]
    Auto Trait Implementations
    impl RefUnwindSafe for And
    impl !Send for And
    impl !Sync for And
    impl Unpin for And
    impl UnwindSafe for And
    Blanket Implementations
    impl<T> Any for T where
        T: 'static + ?Sized,     [src]
    impl<T> Borrow<T> for T where
        T: ?Sized,     [src]
    impl<T> BorrowMut<T> for T where
        T: ?Sized,     [src]
    impl<T> From<T> for T[src]
    impl<T, U> Into<U> for T where
        U: From<T>,     [src]
    impl<T> Spanned for T where
        T: Spanned + ?Sized,     [src]
    impl<T> ToOwned for T where
        T: Clone,     [src]
    type Owned = T
    The resulting type after obtaining ownership.
    
-
    impl<T> ToOwned for T where
        T: Clone,     [src]
    type Owned = T
    The resulting type after obtaining ownership.
    
+
    impl<T, U> TryFrom<U> for T where
        U: Into<T>,     [src]
    type Error = Infallible
    The type returned in the event of a conversion error.
    
-
    impl<T, U> TryInto<U> for T where
        U: TryFrom<T>,     [src]
    type Error = <U as TryFrom<T>>::Error
    The type returned in the event of a conversion error.
    
-
    
\ No newline at end of file
+

    impl<T, U> TryFrom<U> for T where
        U: Into<T>,     [src]

    type Error = Infallible

    The type returned in the event of a conversion error.

    +

    impl<T, U> TryInto<U> for T where
        U: TryFrom<T>,     [src]

    type Error = <U as TryFrom<T>>::Error

    The type returned in the event of a conversion error.

    +
    + \ No newline at end of file diff --git a/syn/token/struct.AndAnd.html b/syn/token/struct.AndAnd.html index 55758b0..3b48c4e 100644 --- a/syn/token/struct.AndAnd.html +++ b/syn/token/struct.AndAnd.html @@ -1,37 +1,38 @@ -syn::token::AndAnd - Rust +syn::token::AndAnd - Rust -

    [−][src]Struct syn::token::AndAnd

    #[repr(C)]pub struct AndAnd {
+
    Struct syn::token::AndAnd[−][src]
    #[repr(C)]pub struct AndAnd {
     pub spans: [Span; 2],
 }
    &&
    
-
    Don't try to remember the name of this type — use the
+
    Don’t try to remember the name of this type — use the
 Token! macro instead.
    
 
    
                        Fields
    spans: [Span; 2]
    Trait Implementations
    impl Clone for AndAnd[src]
    impl Copy for AndAnd[src]
    impl Debug for AndAnd[src]
    impl Default for AndAnd[src]
    impl Default for AndAnd[src]
    impl Eq for AndAnd[src]
    impl Hash for AndAnd[src]
    impl Parse for AndAnd[src]
    impl PartialEq<AndAnd> for AndAnd[src]
    impl ToTokens for AndAnd[src]
    impl Token for AndAnd[src]
    Auto Trait Implementations
    Blanket Implementations
    impl<T> Any for T where
        T: 'static + ?Sized,     [src]
    impl<T> Borrow<T> for T where
        T: ?Sized,     [src]
    impl<T> BorrowMut<T> for T where
        T: ?Sized,     [src]
    impl<T> From<T> for T[src]
    impl<T, U> Into<U> for T where
        U: From<T>,     [src]
    impl Token for AndAnd[src]
    Auto Trait Implementations
    impl RefUnwindSafe for AndAnd
    impl !Send for AndAnd
    impl !Sync for AndAnd
    impl Unpin for AndAnd
    impl UnwindSafe for AndAnd
    Blanket Implementations
    impl<T> Any for T where
        T: 'static + ?Sized,     [src]
    impl<T> Borrow<T> for T where
        T: ?Sized,     [src]
    impl<T> BorrowMut<T> for T where
        T: ?Sized,     [src]
    impl<T> From<T> for T[src]
    impl<T, U> Into<U> for T where
        U: From<T>,     [src]
    impl<T> Spanned for T where
        T: Spanned + ?Sized,     [src]
    impl<T> ToOwned for T where
        T: Clone,     [src]
    type Owned = T
    The resulting type after obtaining ownership.
    
-
    impl<T> ToOwned for T where
        T: Clone,     [src]
    type Owned = T
    The resulting type after obtaining ownership.
    
+
    impl<T, U> TryFrom<U> for T where
        U: Into<T>,     [src]
    type Error = Infallible
    The type returned in the event of a conversion error.
    
-
    impl<T, U> TryInto<U> for T where
        U: TryFrom<T>,     [src]
    type Error = <U as TryFrom<T>>::Error
    The type returned in the event of a conversion error.
    
-
    
\ No newline at end of file
+

    impl<T, U> TryFrom<U> for T where
        U: Into<T>,     [src]

    type Error = Infallible

    The type returned in the event of a conversion error.

    +

    impl<T, U> TryInto<U> for T where
        U: TryFrom<T>,     [src]

    type Error = <U as TryFrom<T>>::Error

    The type returned in the event of a conversion error.

    +
    + \ No newline at end of file diff --git a/syn/token/struct.AndEq.html b/syn/token/struct.AndEq.html index c30b1c8..d398359 100644 --- a/syn/token/struct.AndEq.html +++ b/syn/token/struct.AndEq.html @@ -1,37 +1,38 @@ -syn::token::AndEq - Rust +syn::token::AndEq - Rust -

    [−][src]Struct syn::token::AndEq

    #[repr(C)]pub struct AndEq {
+
    Struct syn::token::AndEq[−][src]
    #[repr(C)]pub struct AndEq {
     pub spans: [Span; 2],
 }
    &=
    
-
    Don't try to remember the name of this type — use the
+
    Don’t try to remember the name of this type — use the
 Token! macro instead.
    
 
    
                        Fields
    spans: [Span; 2]
    Trait Implementations
    impl Clone for AndEq[src]
    impl Copy for AndEq[src]
    impl Debug for AndEq[src]
    impl Default for AndEq[src]
    impl Default for AndEq[src]
    impl Eq for AndEq[src]
    impl Hash for AndEq[src]
    impl Parse for AndEq[src]
    impl PartialEq<AndEq> for AndEq[src]
    impl ToTokens for AndEq[src]
    impl Token for AndEq[src]
    Auto Trait Implementations
    Blanket Implementations
    impl<T> Any for T where
        T: 'static + ?Sized,     [src]
    impl<T> Borrow<T> for T where
        T: ?Sized,     [src]
    impl<T> BorrowMut<T> for T where
        T: ?Sized,     [src]
    impl<T> From<T> for T[src]
    impl<T, U> Into<U> for T where
        U: From<T>,     [src]
    impl Token for AndEq[src]
    Auto Trait Implementations
    impl RefUnwindSafe for AndEq
    impl !Send for AndEq
    impl !Sync for AndEq
    impl Unpin for AndEq
    impl UnwindSafe for AndEq
    Blanket Implementations
    impl<T> Any for T where
        T: 'static + ?Sized,     [src]
    impl<T> Borrow<T> for T where
        T: ?Sized,     [src]
    impl<T> BorrowMut<T> for T where
        T: ?Sized,     [src]
    impl<T> From<T> for T[src]
    impl<T, U> Into<U> for T where
        U: From<T>,     [src]
    impl<T> Spanned for T where
        T: Spanned + ?Sized,     [src]
    impl<T> ToOwned for T where
        T: Clone,     [src]
    type Owned = T
    The resulting type after obtaining ownership.
    
-
    impl<T> ToOwned for T where
        T: Clone,     [src]
    type Owned = T
    The resulting type after obtaining ownership.
    
+
    impl<T, U> TryFrom<U> for T where
        U: Into<T>,     [src]
    type Error = Infallible
    The type returned in the event of a conversion error.
    
-
    impl<T, U> TryInto<U> for T where
        U: TryFrom<T>,     [src]
    type Error = <U as TryFrom<T>>::Error
    The type returned in the event of a conversion error.
    
-
    
\ No newline at end of file
+

    impl<T, U> TryFrom<U> for T where
        U: Into<T>,     [src]

    type Error = Infallible

    The type returned in the event of a conversion error.

    +

    impl<T, U> TryInto<U> for T where
        U: TryFrom<T>,     [src]

    type Error = <U as TryFrom<T>>::Error

    The type returned in the event of a conversion error.

    +
    + \ No newline at end of file diff --git a/syn/token/struct.As.html b/syn/token/struct.As.html index 554c125..13eb9d1 100644 --- a/syn/token/struct.As.html +++ b/syn/token/struct.As.html @@ -1,37 +1,38 @@ -syn::token::As - Rust +syn::token::As - Rust -

    [−][src]Struct syn::token::As

    pub struct As {
+
    Struct syn::token::As[−][src]
    pub struct As {
     pub span: Span,
 }
    as
    
-
    Don't try to remember the name of this type — use the
+
    Don’t try to remember the name of this type — use the
 Token! macro instead.
    
 
    
                        Fields
    span: Span
    Trait Implementations
    impl Clone for As[src]
    impl Copy for As[src]
    impl Debug for As[src]
    impl Default for As[src]
    impl Default for As[src]
    impl Eq for As[src]
    impl Hash for As[src]
    impl Parse for As[src]
    impl PartialEq<As> for As[src]
    impl ToTokens for As[src]
    impl Token for As[src]
    Auto Trait Implementations
    impl RefUnwindSafe for As[src]
    impl !Send for As[src]
    impl !Sync for As[src]
    impl Unpin for As[src]
    impl UnwindSafe for As[src]
    Blanket Implementations
    impl<T> Any for T where
        T: 'static + ?Sized,     [src]
    impl<T> Borrow<T> for T where
        T: ?Sized,     [src]
    impl<T> BorrowMut<T> for T where
        T: ?Sized,     [src]
    impl<T> From<T> for T[src]
    impl<T, U> Into<U> for T where
        U: From<T>,     [src]
    impl Token for As[src]
    Auto Trait Implementations
    impl RefUnwindSafe for As
    impl !Send for As
    impl !Sync for As
    impl Unpin for As
    impl UnwindSafe for As
    Blanket Implementations
    impl<T> Any for T where
        T: 'static + ?Sized,     [src]
    impl<T> Borrow<T> for T where
        T: ?Sized,     [src]
    impl<T> BorrowMut<T> for T where
        T: ?Sized,     [src]
    impl<T> From<T> for T[src]
    impl<T, U> Into<U> for T where
        U: From<T>,     [src]
    impl<T> Spanned for T where
        T: Spanned + ?Sized,     [src]
    impl<T> ToOwned for T where
        T: Clone,     [src]
    type Owned = T
    The resulting type after obtaining ownership.
    
-
    impl<T> ToOwned for T where
        T: Clone,     [src]
    type Owned = T
    The resulting type after obtaining ownership.
    
+
    impl<T, U> TryFrom<U> for T where
        U: Into<T>,     [src]
    type Error = Infallible
    The type returned in the event of a conversion error.
    
-
    impl<T, U> TryInto<U> for T where
        U: TryFrom<T>,     [src]
    type Error = <U as TryFrom<T>>::Error
    The type returned in the event of a conversion error.
    
-
    
\ No newline at end of file
+

    impl<T, U> TryFrom<U> for T where
        U: Into<T>,     [src]

    type Error = Infallible

    The type returned in the event of a conversion error.

    +

    impl<T, U> TryInto<U> for T where
        U: TryFrom<T>,     [src]

    type Error = <U as TryFrom<T>>::Error

    The type returned in the event of a conversion error.

    +
    + \ No newline at end of file diff --git a/syn/token/struct.Async.html b/syn/token/struct.Async.html index 4e87429..bfcd6c0 100644 --- a/syn/token/struct.Async.html +++ b/syn/token/struct.Async.html @@ -1,37 +1,38 @@ -syn::token::Async - Rust +syn::token::Async - Rust -

    [−][src]Struct syn::token::Async

    pub struct Async {
+
    Struct syn::token::Async[−][src]
    pub struct Async {
     pub span: Span,
 }
    async
    
-
    Don't try to remember the name of this type — use the
+
    Don’t try to remember the name of this type — use the
 Token! macro instead.
    
 
    
                        Fields
    span: Span
    Trait Implementations
    impl Clone for Async[src]
    impl Copy for Async[src]
    impl Debug for Async[src]
    impl Default for Async[src]
    impl Default for Async[src]
    impl Eq for Async[src]
    impl Hash for Async[src]
    impl Parse for Async[src]
    impl PartialEq<Async> for Async[src]
    impl ToTokens for Async[src]
    impl Token for Async[src]
    Auto Trait Implementations
    Blanket Implementations
    impl<T> Any for T where
        T: 'static + ?Sized,     [src]
    impl<T> Borrow<T> for T where
        T: ?Sized,     [src]
    impl<T> BorrowMut<T> for T where
        T: ?Sized,     [src]
    impl<T> From<T> for T[src]
    impl<T, U> Into<U> for T where
        U: From<T>,     [src]
    impl Token for Async[src]
    Auto Trait Implementations
    impl RefUnwindSafe for Async
    impl !Send for Async
    impl !Sync for Async
    impl Unpin for Async
    impl UnwindSafe for Async
    Blanket Implementations
    impl<T> Any for T where
        T: 'static + ?Sized,     [src]
    impl<T> Borrow<T> for T where
        T: ?Sized,     [src]
    impl<T> BorrowMut<T> for T where
        T: ?Sized,     [src]
    impl<T> From<T> for T[src]
    impl<T, U> Into<U> for T where
        U: From<T>,     [src]
    impl<T> Spanned for T where
        T: Spanned + ?Sized,     [src]
    impl<T> ToOwned for T where
        T: Clone,     [src]
    type Owned = T
    The resulting type after obtaining ownership.
    
-
    impl<T> ToOwned for T where
        T: Clone,     [src]
    type Owned = T
    The resulting type after obtaining ownership.
    
+
    impl<T, U> TryFrom<U> for T where
        U: Into<T>,     [src]
    type Error = Infallible
    The type returned in the event of a conversion error.
    
-
    impl<T, U> TryInto<U> for T where
        U: TryFrom<T>,     [src]
    type Error = <U as TryFrom<T>>::Error
    The type returned in the event of a conversion error.
    
-
    
\ No newline at end of file
+

    impl<T, U> TryFrom<U> for T where
        U: Into<T>,     [src]

    type Error = Infallible

    The type returned in the event of a conversion error.

    +

    impl<T, U> TryInto<U> for T where
        U: TryFrom<T>,     [src]

    type Error = <U as TryFrom<T>>::Error

    The type returned in the event of a conversion error.

    +
    + \ No newline at end of file diff --git a/syn/token/struct.At.html b/syn/token/struct.At.html index 1e1ca21..69ed1e6 100644 --- a/syn/token/struct.At.html +++ b/syn/token/struct.At.html @@ -1,40 +1,41 @@ -syn::token::At - Rust +syn::token::At - Rust -

    [−][src]Struct syn::token::At

    #[repr(C)]pub struct At {
+
    Struct syn::token::At[−][src]
    #[repr(C)]pub struct At {
     pub spans: [Span; 1],
 }
    @
    
-
    Don't try to remember the name of this type — use the
+
    Don’t try to remember the name of this type — use the
 Token! macro instead.
    
 
    
                        Fields
    spans: [Span; 1]
    Trait Implementations
    impl Clone for At[src]
    impl Copy for At[src]
    impl Debug for At[src]
    impl Default for At[src]
    impl Default for At[src]
    impl Deref for At[src]
    type Target = WithSpan
    The resulting type after dereferencing.
    
 
    impl DerefMut for At[src]
    impl Eq for At[src]
    impl Hash for At[src]
    impl Parse for At[src]
    impl PartialEq<At> for At[src]
    impl ToTokens for At[src]
    impl Token for At[src]
    Auto Trait Implementations
    impl RefUnwindSafe for At[src]
    impl !Send for At[src]
    impl !Sync for At[src]
    impl Unpin for At[src]
    impl UnwindSafe for At[src]
    Blanket Implementations
    impl<T> Any for T where
        T: 'static + ?Sized,     [src]
    impl<T> Borrow<T> for T where
        T: ?Sized,     [src]
    impl<T> BorrowMut<T> for T where
        T: ?Sized,     [src]
    impl<T> From<T> for T[src]
    impl<T, U> Into<U> for T where
        U: From<T>,     [src]
    impl Token for At[src]
    Auto Trait Implementations
    impl RefUnwindSafe for At
    impl !Send for At
    impl !Sync for At
    impl Unpin for At
    impl UnwindSafe for At
    Blanket Implementations
    impl<T> Any for T where
        T: 'static + ?Sized,     [src]
    impl<T> Borrow<T> for T where
        T: ?Sized,     [src]
    impl<T> BorrowMut<T> for T where
        T: ?Sized,     [src]
    impl<T> From<T> for T[src]
    impl<T, U> Into<U> for T where
        U: From<T>,     [src]
    impl<T> Spanned for T where
        T: Spanned + ?Sized,     [src]
    impl<T> ToOwned for T where
        T: Clone,     [src]
    type Owned = T
    The resulting type after obtaining ownership.
    
-
    impl<T> ToOwned for T where
        T: Clone,     [src]
    type Owned = T
    The resulting type after obtaining ownership.
    
+
    impl<T, U> TryFrom<U> for T where
        U: Into<T>,     [src]
    type Error = Infallible
    The type returned in the event of a conversion error.
    
-
    impl<T, U> TryInto<U> for T where
        U: TryFrom<T>,     [src]
    type Error = <U as TryFrom<T>>::Error
    The type returned in the event of a conversion error.
    
-
    
\ No newline at end of file
+

    impl<T, U> TryFrom<U> for T where
        U: Into<T>,     [src]

    type Error = Infallible

    The type returned in the event of a conversion error.

    +

    impl<T, U> TryInto<U> for T where
        U: TryFrom<T>,     [src]

    type Error = <U as TryFrom<T>>::Error

    The type returned in the event of a conversion error.

    +
    + \ No newline at end of file diff --git a/syn/token/struct.Auto.html b/syn/token/struct.Auto.html index c2c7df1..a209c84 100644 --- a/syn/token/struct.Auto.html +++ b/syn/token/struct.Auto.html @@ -1,37 +1,38 @@ -syn::token::Auto - Rust +syn::token::Auto - Rust -

    [−][src]Struct syn::token::Auto

    pub struct Auto {
+
    Struct syn::token::Auto[−][src]
    pub struct Auto {
     pub span: Span,
 }
    auto
    
-
    Don't try to remember the name of this type — use the
+
    Don’t try to remember the name of this type — use the
 Token! macro instead.
    
 
    
                        Fields
    span: Span
    Trait Implementations
    impl Clone for Auto[src]
    impl Copy for Auto[src]
    impl Debug for Auto[src]
    impl Default for Auto[src]
    impl Default for Auto[src]
    impl Eq for Auto[src]
    impl Hash for Auto[src]
    impl Parse for Auto[src]
    impl PartialEq<Auto> for Auto[src]
    impl ToTokens for Auto[src]
    impl Token for Auto[src]
    Auto Trait Implementations
    Blanket Implementations
    impl<T> Any for T where
        T: 'static + ?Sized,     [src]
    impl<T> Borrow<T> for T where
        T: ?Sized,     [src]
    impl<T> BorrowMut<T> for T where
        T: ?Sized,     [src]
    impl<T> From<T> for T[src]
    impl<T, U> Into<U> for T where
        U: From<T>,     [src]
    impl Token for Auto[src]
    Auto Trait Implementations
    impl RefUnwindSafe for Auto
    impl !Send for Auto
    impl !Sync for Auto
    impl Unpin for Auto
    impl UnwindSafe for Auto
    Blanket Implementations
    impl<T> Any for T where
        T: 'static + ?Sized,     [src]
    impl<T> Borrow<T> for T where
        T: ?Sized,     [src]
    impl<T> BorrowMut<T> for T where
        T: ?Sized,     [src]
    impl<T> From<T> for T[src]
    impl<T, U> Into<U> for T where
        U: From<T>,     [src]
    impl<T> Spanned for T where
        T: Spanned + ?Sized,     [src]
    impl<T> ToOwned for T where
        T: Clone,     [src]
    type Owned = T
    The resulting type after obtaining ownership.
    
-
    impl<T> ToOwned for T where
        T: Clone,     [src]
    type Owned = T
    The resulting type after obtaining ownership.
    
+
    impl<T, U> TryFrom<U> for T where
        U: Into<T>,     [src]
    type Error = Infallible
    The type returned in the event of a conversion error.
    
-
    impl<T, U> TryInto<U> for T where
        U: TryFrom<T>,     [src]
    type Error = <U as TryFrom<T>>::Error
    The type returned in the event of a conversion error.
    
-
    
\ No newline at end of file
+

    impl<T, U> TryFrom<U> for T where
        U: Into<T>,     [src]

    type Error = Infallible

    The type returned in the event of a conversion error.

    +

    impl<T, U> TryInto<U> for T where
        U: TryFrom<T>,     [src]

    type Error = <U as TryFrom<T>>::Error

    The type returned in the event of a conversion error.

    +
    + \ No newline at end of file diff --git a/syn/token/struct.Await.html b/syn/token/struct.Await.html index 6f2d57c..e042fc5 100644 --- a/syn/token/struct.Await.html +++ b/syn/token/struct.Await.html @@ -1,37 +1,38 @@ -syn::token::Await - Rust +syn::token::Await - Rust -

    [−][src]Struct syn::token::Await

    pub struct Await {
+
    Struct syn::token::Await[−][src]
    pub struct Await {
     pub span: Span,
 }
    await
    
-
    Don't try to remember the name of this type — use the
+
    Don’t try to remember the name of this type — use the
 Token! macro instead.
    
 
    
                        Fields
    span: Span
    Trait Implementations
    impl Clone for Await[src]
    impl Copy for Await[src]
    impl Debug for Await[src]
    impl Default for Await[src]
    impl Default for Await[src]
    impl Eq for Await[src]
    impl Hash for Await[src]
    impl Parse for Await[src]
    impl PartialEq<Await> for Await[src]
    impl ToTokens for Await[src]
    impl Token for Await[src]
    Auto Trait Implementations
    Blanket Implementations
    impl<T> Any for T where
        T: 'static + ?Sized,     [src]
    impl<T> Borrow<T> for T where
        T: ?Sized,     [src]
    impl<T> BorrowMut<T> for T where
        T: ?Sized,     [src]
    impl<T> From<T> for T[src]
    impl<T, U> Into<U> for T where
        U: From<T>,     [src]
    impl Token for Await[src]
    Auto Trait Implementations
    impl RefUnwindSafe for Await
    impl !Send for Await
    impl !Sync for Await
    impl Unpin for Await
    impl UnwindSafe for Await
    Blanket Implementations
    impl<T> Any for T where
        T: 'static + ?Sized,     [src]
    impl<T> Borrow<T> for T where
        T: ?Sized,     [src]
    impl<T> BorrowMut<T> for T where
        T: ?Sized,     [src]
    impl<T> From<T> for T[src]
    impl<T, U> Into<U> for T where
        U: From<T>,     [src]
    impl<T> Spanned for T where
        T: Spanned + ?Sized,     [src]
    impl<T> ToOwned for T where
        T: Clone,     [src]
    type Owned = T
    The resulting type after obtaining ownership.
    
-
    impl<T> ToOwned for T where
        T: Clone,     [src]
    type Owned = T
    The resulting type after obtaining ownership.
    
+
    impl<T, U> TryFrom<U> for T where
        U: Into<T>,     [src]
    type Error = Infallible
    The type returned in the event of a conversion error.
    
-
    impl<T, U> TryInto<U> for T where
        U: TryFrom<T>,     [src]
    type Error = <U as TryFrom<T>>::Error
    The type returned in the event of a conversion error.
    
-
    
\ No newline at end of file
+

    impl<T, U> TryFrom<U> for T where
        U: Into<T>,     [src]

    type Error = Infallible

    The type returned in the event of a conversion error.

    +

    impl<T, U> TryInto<U> for T where
        U: TryFrom<T>,     [src]

    type Error = <U as TryFrom<T>>::Error

    The type returned in the event of a conversion error.

    +
    + \ No newline at end of file diff --git a/syn/token/struct.Bang.html b/syn/token/struct.Bang.html index f902fbd..c82ea8d 100644 --- a/syn/token/struct.Bang.html +++ b/syn/token/struct.Bang.html @@ -1,40 +1,41 @@ -syn::token::Bang - Rust +syn::token::Bang - Rust -

    [−][src]Struct syn::token::Bang

    #[repr(C)]pub struct Bang {
+
    Struct syn::token::Bang[−][src]
    #[repr(C)]pub struct Bang {
     pub spans: [Span; 1],
 }
    !
    
-
    Don't try to remember the name of this type — use the
+
    Don’t try to remember the name of this type — use the
 Token! macro instead.
    
 
    
                        Fields
    spans: [Span; 1]
    Trait Implementations
    impl Clone for Bang[src]
    impl Copy for Bang[src]
    impl Debug for Bang[src]
    impl Default for Bang[src]
    impl Default for Bang[src]
    impl Deref for Bang[src]
    type Target = WithSpan
    The resulting type after dereferencing.
    
 
    impl DerefMut for Bang[src]
    impl Eq for Bang[src]
    impl Hash for Bang[src]
    impl Parse for Bang[src]
    impl PartialEq<Bang> for Bang[src]
    impl ToTokens for Bang[src]
    impl Token for Bang[src]
    Auto Trait Implementations
    Blanket Implementations
    impl<T> Any for T where
        T: 'static + ?Sized,     [src]
    impl<T> Borrow<T> for T where
        T: ?Sized,     [src]
    impl<T> BorrowMut<T> for T where
        T: ?Sized,     [src]
    impl<T> From<T> for T[src]
    impl<T, U> Into<U> for T where
        U: From<T>,     [src]
    impl Token for Bang[src]
    Auto Trait Implementations
    impl RefUnwindSafe for Bang
    impl !Send for Bang
    impl !Sync for Bang
    impl Unpin for Bang
    impl UnwindSafe for Bang
    Blanket Implementations
    impl<T> Any for T where
        T: 'static + ?Sized,     [src]
    impl<T> Borrow<T> for T where
        T: ?Sized,     [src]
    impl<T> BorrowMut<T> for T where
        T: ?Sized,     [src]
    impl<T> From<T> for T[src]
    impl<T, U> Into<U> for T where
        U: From<T>,     [src]
    impl<T> Spanned for T where
        T: Spanned + ?Sized,     [src]
    impl<T> ToOwned for T where
        T: Clone,     [src]
    type Owned = T
    The resulting type after obtaining ownership.
    
-
    impl<T> ToOwned for T where
        T: Clone,     [src]
    type Owned = T
    The resulting type after obtaining ownership.
    
+
    impl<T, U> TryFrom<U> for T where
        U: Into<T>,     [src]
    type Error = Infallible
    The type returned in the event of a conversion error.
    
-
    impl<T, U> TryInto<U> for T where
        U: TryFrom<T>,     [src]
    type Error = <U as TryFrom<T>>::Error
    The type returned in the event of a conversion error.
    
-
    
\ No newline at end of file
+

    impl<T, U> TryFrom<U> for T where
        U: Into<T>,     [src]

    type Error = Infallible

    The type returned in the event of a conversion error.

    +

    impl<T, U> TryInto<U> for T where
        U: TryFrom<T>,     [src]

    type Error = <U as TryFrom<T>>::Error

    The type returned in the event of a conversion error.

    +
    + \ No newline at end of file diff --git a/syn/token/struct.Become.html b/syn/token/struct.Become.html index b07fe17..57f672b 100644 --- a/syn/token/struct.Become.html +++ b/syn/token/struct.Become.html @@ -1,37 +1,38 @@ -syn::token::Become - Rust +syn::token::Become - Rust -

    [−][src]Struct syn::token::Become

    pub struct Become {
+
    Struct syn::token::Become[−][src]
    pub struct Become {
     pub span: Span,
 }
    become
    
-
    Don't try to remember the name of this type — use the
+
    Don’t try to remember the name of this type — use the
 Token! macro instead.
    
 
    
                        Fields
    span: Span
    Trait Implementations
    impl Clone for Become[src]
    impl Copy for Become[src]
    impl Debug for Become[src]
    impl Default for Become[src]
    impl Default for Become[src]
    impl Eq for Become[src]
    impl Hash for Become[src]
    impl Parse for Become[src]
    impl PartialEq<Become> for Become[src]
    impl ToTokens for Become[src]
    impl Token for Become[src]
    Auto Trait Implementations
    Blanket Implementations
    impl<T> Any for T where
        T: 'static + ?Sized,     [src]
    impl<T> Borrow<T> for T where
        T: ?Sized,     [src]
    impl<T> BorrowMut<T> for T where
        T: ?Sized,     [src]
    impl<T> From<T> for T[src]
    impl<T, U> Into<U> for T where
        U: From<T>,     [src]
    impl Token for Become[src]
    Auto Trait Implementations
    impl RefUnwindSafe for Become
    impl !Send for Become
    impl !Sync for Become
    impl Unpin for Become
    impl UnwindSafe for Become
    Blanket Implementations
    impl<T> Any for T where
        T: 'static + ?Sized,     [src]
    impl<T> Borrow<T> for T where
        T: ?Sized,     [src]
    impl<T> BorrowMut<T> for T where
        T: ?Sized,     [src]
    impl<T> From<T> for T[src]
    impl<T, U> Into<U> for T where
        U: From<T>,     [src]
    impl<T> Spanned for T where
        T: Spanned + ?Sized,     [src]
    impl<T> ToOwned for T where
        T: Clone,     [src]
    type Owned = T
    The resulting type after obtaining ownership.
    
-
    impl<T> ToOwned for T where
        T: Clone,     [src]
    type Owned = T
    The resulting type after obtaining ownership.
    
+
    impl<T, U> TryFrom<U> for T where
        U: Into<T>,     [src]
    type Error = Infallible
    The type returned in the event of a conversion error.
    
-
    impl<T, U> TryInto<U> for T where
        U: TryFrom<T>,     [src]
    type Error = <U as TryFrom<T>>::Error
    The type returned in the event of a conversion error.
    
-
    
\ No newline at end of file
+

    impl<T, U> TryFrom<U> for T where
        U: Into<T>,     [src]

    type Error = Infallible

    The type returned in the event of a conversion error.

    +

    impl<T, U> TryInto<U> for T where
        U: TryFrom<T>,     [src]

    type Error = <U as TryFrom<T>>::Error

    The type returned in the event of a conversion error.

    +
    + \ No newline at end of file diff --git a/syn/token/struct.Box.html b/syn/token/struct.Box.html index 6ed1579..da72eea 100644 --- a/syn/token/struct.Box.html +++ b/syn/token/struct.Box.html @@ -1,37 +1,38 @@ -syn::token::Box - Rust +syn::token::Box - Rust -

    [−][src]Struct syn::token::Box

    pub struct Box {
+
    Struct syn::token::Box[−][src]
    pub struct Box {
     pub span: Span,
 }
    box
    
-
    Don't try to remember the name of this type — use the
+
    Don’t try to remember the name of this type — use the
 Token! macro instead.
    
 
    
                        Fields
    span: Span
    Trait Implementations
    impl Clone for Box[src]
    impl Copy for Box[src]
    impl Debug for Box[src]
    impl Default for Box[src]
    impl Default for Box[src]
    impl Eq for Box[src]
    impl Hash for Box[src]
    impl Parse for Box[src]
    impl PartialEq<Box> for Box[src]
    impl ToTokens for Box[src]
    impl Token for Box[src]
    Auto Trait Implementations
    impl RefUnwindSafe for Box[src]
    impl !Send for Box[src]
    impl !Sync for Box[src]
    impl Unpin for Box[src]
    impl UnwindSafe for Box[src]
    Blanket Implementations
    impl<T> Any for T where
        T: 'static + ?Sized,     [src]
    impl<T> Borrow<T> for T where
        T: ?Sized,     [src]
    impl<T> BorrowMut<T> for T where
        T: ?Sized,     [src]
    impl<T> From<T> for T[src]
    impl<T, U> Into<U> for T where
        U: From<T>,     [src]
    impl Token for Box[src]
    Auto Trait Implementations
    impl RefUnwindSafe for Box
    impl !Send for Box
    impl !Sync for Box
    impl Unpin for Box
    impl UnwindSafe for Box
    Blanket Implementations
    impl<T> Any for T where
        T: 'static + ?Sized,     [src]
    impl<T> Borrow<T> for T where
        T: ?Sized,     [src]
    impl<T> BorrowMut<T> for T where
        T: ?Sized,     [src]
    impl<T> From<T> for T[src]
    impl<T, U> Into<U> for T where
        U: From<T>,     [src]
    impl<T> Spanned for T where
        T: Spanned + ?Sized,     [src]
    impl<T> ToOwned for T where
        T: Clone,     [src]
    type Owned = T
    The resulting type after obtaining ownership.
    
-
    impl<T> ToOwned for T where
        T: Clone,     [src]
    type Owned = T
    The resulting type after obtaining ownership.
    
+
    impl<T, U> TryFrom<U> for T where
        U: Into<T>,     [src]
    type Error = Infallible
    The type returned in the event of a conversion error.
    
-
    impl<T, U> TryInto<U> for T where
        U: TryFrom<T>,     [src]
    type Error = <U as TryFrom<T>>::Error
    The type returned in the event of a conversion error.
    
-
    
\ No newline at end of file
+

    impl<T, U> TryFrom<U> for T where
        U: Into<T>,     [src]

    type Error = Infallible

    The type returned in the event of a conversion error.

    +

    impl<T, U> TryInto<U> for T where
        U: TryFrom<T>,     [src]

    type Error = <U as TryFrom<T>>::Error

    The type returned in the event of a conversion error.

    +
    + \ No newline at end of file diff --git a/syn/token/struct.Brace.html b/syn/token/struct.Brace.html index 4179c20..df6c0af 100644 --- a/syn/token/struct.Brace.html +++ b/syn/token/struct.Brace.html @@ -1,30 +1,31 @@ -syn::token::Brace - Rust +syn::token::Brace - Rust -

    [−][src]Struct syn::token::Brace

    pub struct Brace {
+
    Struct syn::token::Brace[−][src]
    pub struct Brace {
     pub span: Span,
 }
    {...}
    
 
    
                        Fields
    span: Span
    Implementations
    impl Brace[src]
    pub fn surround<F>(&self, tokens: &mut TokenStream, f: F) where
        F: FnOnce(&mut TokenStream),     [src]
    Trait Implementations
    impl Clone for Brace[src]
    impl Copy for Brace[src]
    impl Debug for Brace[src]
    impl Default for Brace[src]
    impl Default for Brace[src]
    impl Eq for Brace[src]
    impl Hash for Brace[src]
    impl PartialEq<Brace> for Brace[src]
    impl Token for Brace[src]
    Auto Trait Implementations
    Blanket Implementations
    impl<T> Any for T where
        T: 'static + ?Sized,     [src]
    impl<T> Borrow<T> for T where
        T: ?Sized,     [src]
    impl<T> BorrowMut<T> for T where
        T: ?Sized,     [src]
    impl<T> From<T> for T[src]
    impl<T, U> Into<U> for T where
        U: From<T>,     [src]
    impl<T> ToOwned for T where
        T: Clone,     [src]
    type Owned = T
    The resulting type after obtaining ownership.
    
-
    impl Token for Brace[src]
    Auto Trait Implementations
    impl RefUnwindSafe for Brace
    impl !Send for Brace
    impl !Sync for Brace
    impl Unpin for Brace
    impl UnwindSafe for Brace
    Blanket Implementations
    impl<T> Any for T where
        T: 'static + ?Sized,     [src]
    impl<T> Borrow<T> for T where
        T: ?Sized,     [src]
    impl<T> BorrowMut<T> for T where
        T: ?Sized,     [src]
    impl<T> From<T> for T[src]
    impl<T, U> Into<U> for T where
        U: From<T>,     [src]
    impl<T> ToOwned for T where
        T: Clone,     [src]
    type Owned = T
    The resulting type after obtaining ownership.
    
+
    impl<T, U> TryFrom<U> for T where
        U: Into<T>,     [src]
    type Error = Infallible
    The type returned in the event of a conversion error.
    
-
    impl<T, U> TryInto<U> for T where
        U: TryFrom<T>,     [src]
    type Error = <U as TryFrom<T>>::Error
    The type returned in the event of a conversion error.
    
-
    
\ No newline at end of file
+

    impl<T, U> TryFrom<U> for T where
        U: Into<T>,     [src]

    type Error = Infallible

    The type returned in the event of a conversion error.

    +

    impl<T, U> TryInto<U> for T where
        U: TryFrom<T>,     [src]

    type Error = <U as TryFrom<T>>::Error

    The type returned in the event of a conversion error.

    +
    + \ No newline at end of file diff --git a/syn/token/struct.Bracket.html b/syn/token/struct.Bracket.html index 1c6dad4..b04e6bc 100644 --- a/syn/token/struct.Bracket.html +++ b/syn/token/struct.Bracket.html @@ -1,30 +1,31 @@ -syn::token::Bracket - Rust +syn::token::Bracket - Rust -

    [−][src]Struct syn::token::Bracket

    pub struct Bracket {
+
    Struct syn::token::Bracket[−][src]
    pub struct Bracket {
     pub span: Span,
 }
    [...]
    
 
    
                        Fields
    span: Span
    Implementations
    impl Bracket[src]
    pub fn surround<F>(&self, tokens: &mut TokenStream, f: F) where
        F: FnOnce(&mut TokenStream),     [src]
    Trait Implementations
    impl Clone for Bracket[src]
    impl Copy for Bracket[src]
    impl Debug for Bracket[src]
    impl Default for Bracket[src]
    impl Default for Bracket[src]
    impl Eq for Bracket[src]
    impl Hash for Bracket[src]
    impl PartialEq<Bracket> for Bracket[src]
    impl Token for Bracket[src]
    Auto Trait Implementations
    Blanket Implementations
    impl<T> Any for T where
        T: 'static + ?Sized,     [src]
    impl<T> Borrow<T> for T where
        T: ?Sized,     [src]
    impl<T> BorrowMut<T> for T where
        T: ?Sized,     [src]
    impl<T> From<T> for T[src]
    impl<T, U> Into<U> for T where
        U: From<T>,     [src]
    impl<T> ToOwned for T where
        T: Clone,     [src]
    type Owned = T
    The resulting type after obtaining ownership.
    
-
    impl Token for Bracket[src]
    Auto Trait Implementations
    impl RefUnwindSafe for Bracket
    impl !Send for Bracket
    impl !Sync for Bracket
    impl Unpin for Bracket
    impl UnwindSafe for Bracket
    Blanket Implementations
    impl<T> Any for T where
        T: 'static + ?Sized,     [src]
    impl<T> Borrow<T> for T where
        T: ?Sized,     [src]
    impl<T> BorrowMut<T> for T where
        T: ?Sized,     [src]
    impl<T> From<T> for T[src]
    impl<T, U> Into<U> for T where
        U: From<T>,     [src]
    impl<T> ToOwned for T where
        T: Clone,     [src]
    type Owned = T
    The resulting type after obtaining ownership.
    
+
    impl<T, U> TryFrom<U> for T where
        U: Into<T>,     [src]
    type Error = Infallible
    The type returned in the event of a conversion error.
    
-
    impl<T, U> TryInto<U> for T where
        U: TryFrom<T>,     [src]
    type Error = <U as TryFrom<T>>::Error
    The type returned in the event of a conversion error.
    
-
    
\ No newline at end of file
+

    impl<T, U> TryFrom<U> for T where
        U: Into<T>,     [src]

    type Error = Infallible

    The type returned in the event of a conversion error.

    +

    impl<T, U> TryInto<U> for T where
        U: TryFrom<T>,     [src]

    type Error = <U as TryFrom<T>>::Error

    The type returned in the event of a conversion error.

    +
    + \ No newline at end of file diff --git a/syn/token/struct.Break.html b/syn/token/struct.Break.html index 4831482..ce99244 100644 --- a/syn/token/struct.Break.html +++ b/syn/token/struct.Break.html @@ -1,37 +1,38 @@ -syn::token::Break - Rust +syn::token::Break - Rust -

    [−][src]Struct syn::token::Break

    pub struct Break {
+
    Struct syn::token::Break[−][src]
    pub struct Break {
     pub span: Span,
 }
    break
    
-
    Don't try to remember the name of this type — use the
+
    Don’t try to remember the name of this type — use the
 Token! macro instead.
    
 
    
                        Fields
    span: Span
    Trait Implementations
    impl Clone for Break[src]
    impl Copy for Break[src]
    impl Debug for Break[src]
    impl Default for Break[src]
    impl Default for Break[src]
    impl Eq for Break[src]
    impl Hash for Break[src]
    impl Parse for Break[src]
    impl PartialEq<Break> for Break[src]
    impl ToTokens for Break[src]
    impl Token for Break[src]
    Auto Trait Implementations
    Blanket Implementations
    impl<T> Any for T where
        T: 'static + ?Sized,     [src]
    impl<T> Borrow<T> for T where
        T: ?Sized,     [src]
    impl<T> BorrowMut<T> for T where
        T: ?Sized,     [src]
    impl<T> From<T> for T[src]
    impl<T, U> Into<U> for T where
        U: From<T>,     [src]
    impl Token for Break[src]
    Auto Trait Implementations
    impl RefUnwindSafe for Break
    impl !Send for Break
    impl !Sync for Break
    impl Unpin for Break
    impl UnwindSafe for Break
    Blanket Implementations
    impl<T> Any for T where
        T: 'static + ?Sized,     [src]
    impl<T> Borrow<T> for T where
        T: ?Sized,     [src]
    impl<T> BorrowMut<T> for T where
        T: ?Sized,     [src]
    impl<T> From<T> for T[src]
    impl<T, U> Into<U> for T where
        U: From<T>,     [src]
    impl<T> Spanned for T where
        T: Spanned + ?Sized,     [src]
    impl<T> ToOwned for T where
        T: Clone,     [src]
    type Owned = T
    The resulting type after obtaining ownership.
    
-
    impl<T> ToOwned for T where
        T: Clone,     [src]
    type Owned = T
    The resulting type after obtaining ownership.
    
+
    impl<T, U> TryFrom<U> for T where
        U: Into<T>,     [src]
    type Error = Infallible
    The type returned in the event of a conversion error.
    
-
    impl<T, U> TryInto<U> for T where
        U: TryFrom<T>,     [src]
    type Error = <U as TryFrom<T>>::Error
    The type returned in the event of a conversion error.
    
-
    
\ No newline at end of file
+

    impl<T, U> TryFrom<U> for T where
        U: Into<T>,     [src]

    type Error = Infallible

    The type returned in the event of a conversion error.

    +

    impl<T, U> TryInto<U> for T where
        U: TryFrom<T>,     [src]

    type Error = <U as TryFrom<T>>::Error

    The type returned in the event of a conversion error.

    +
    + \ No newline at end of file diff --git a/syn/token/struct.Caret.html b/syn/token/struct.Caret.html index 54b4754..5446f04 100644 --- a/syn/token/struct.Caret.html +++ b/syn/token/struct.Caret.html @@ -1,40 +1,41 @@ -syn::token::Caret - Rust +syn::token::Caret - Rust -

    [−][src]Struct syn::token::Caret

    #[repr(C)]pub struct Caret {
+
    Struct syn::token::Caret[−][src]
    #[repr(C)]pub struct Caret {
     pub spans: [Span; 1],
 }
    ^
    
-
    Don't try to remember the name of this type — use the
+
    Don’t try to remember the name of this type — use the
 Token! macro instead.
    
 
    
                        Fields
    spans: [Span; 1]
    Trait Implementations
    impl Clone for Caret[src]
    impl Copy for Caret[src]
    impl Debug for Caret[src]
    impl Default for Caret[src]
    impl Default for Caret[src]
    impl Deref for Caret[src]
    type Target = WithSpan
    The resulting type after dereferencing.
    
 
    impl DerefMut for Caret[src]
    impl Eq for Caret[src]
    impl Hash for Caret[src]
    impl Parse for Caret[src]
    impl PartialEq<Caret> for Caret[src]
    impl ToTokens for Caret[src]
    impl Token for Caret[src]
    Auto Trait Implementations
    Blanket Implementations
    impl<T> Any for T where
        T: 'static + ?Sized,     [src]
    impl<T> Borrow<T> for T where
        T: ?Sized,     [src]
    impl<T> BorrowMut<T> for T where
        T: ?Sized,     [src]
    impl<T> From<T> for T[src]
    impl<T, U> Into<U> for T where
        U: From<T>,     [src]
    impl Token for Caret[src]
    Auto Trait Implementations
    impl RefUnwindSafe for Caret
    impl !Send for Caret
    impl !Sync for Caret
    impl Unpin for Caret
    impl UnwindSafe for Caret
    Blanket Implementations
    impl<T> Any for T where
        T: 'static + ?Sized,     [src]
    impl<T> Borrow<T> for T where
        T: ?Sized,     [src]
    impl<T> BorrowMut<T> for T where
        T: ?Sized,     [src]
    impl<T> From<T> for T[src]
    impl<T, U> Into<U> for T where
        U: From<T>,     [src]
    impl<T> Spanned for T where
        T: Spanned + ?Sized,     [src]
    impl<T> ToOwned for T where
        T: Clone,     [src]
    type Owned = T
    The resulting type after obtaining ownership.
    
-
    impl<T> ToOwned for T where
        T: Clone,     [src]
    type Owned = T
    The resulting type after obtaining ownership.
    
+
    impl<T, U> TryFrom<U> for T where
        U: Into<T>,     [src]
    type Error = Infallible
    The type returned in the event of a conversion error.
    
-
    impl<T, U> TryInto<U> for T where
        U: TryFrom<T>,     [src]
    type Error = <U as TryFrom<T>>::Error
    The type returned in the event of a conversion error.
    
-
    
\ No newline at end of file
+

    impl<T, U> TryFrom<U> for T where
        U: Into<T>,     [src]

    type Error = Infallible

    The type returned in the event of a conversion error.

    +

    impl<T, U> TryInto<U> for T where
        U: TryFrom<T>,     [src]

    type Error = <U as TryFrom<T>>::Error

    The type returned in the event of a conversion error.

    +
    + \ No newline at end of file diff --git a/syn/token/struct.CaretEq.html b/syn/token/struct.CaretEq.html index 8140014..cf7adb9 100644 --- a/syn/token/struct.CaretEq.html +++ b/syn/token/struct.CaretEq.html @@ -1,37 +1,38 @@ -syn::token::CaretEq - Rust +syn::token::CaretEq - Rust -

    [−][src]Struct syn::token::CaretEq

    #[repr(C)]pub struct CaretEq {
+
    Struct syn::token::CaretEq[−][src]
    #[repr(C)]pub struct CaretEq {
     pub spans: [Span; 2],
 }
    ^=
    
-
    Don't try to remember the name of this type — use the
+
    Don’t try to remember the name of this type — use the
 Token! macro instead.
    
 
    
                        Fields
    spans: [Span; 2]
    Trait Implementations
    impl Clone for CaretEq[src]
    impl Copy for CaretEq[src]
    impl Debug for CaretEq[src]
    impl Default for CaretEq[src]
    impl Default for CaretEq[src]
    impl Eq for CaretEq[src]
    impl Hash for CaretEq[src]
    impl Parse for CaretEq[src]
    impl PartialEq<CaretEq> for CaretEq[src]
    impl ToTokens for CaretEq[src]
    impl Token for CaretEq[src]
    Auto Trait Implementations
    Blanket Implementations
    impl<T> Any for T where
        T: 'static + ?Sized,     [src]
    impl<T> Borrow<T> for T where
        T: ?Sized,     [src]
    impl<T> BorrowMut<T> for T where
        T: ?Sized,     [src]
    impl<T> From<T> for T[src]
    impl<T, U> Into<U> for T where
        U: From<T>,     [src]
    impl Token for CaretEq[src]
    Auto Trait Implementations
    impl RefUnwindSafe for CaretEq
    impl !Send for CaretEq
    impl !Sync for CaretEq
    impl Unpin for CaretEq
    impl UnwindSafe for CaretEq
    Blanket Implementations
    impl<T> Any for T where
        T: 'static + ?Sized,     [src]
    impl<T> Borrow<T> for T where
        T: ?Sized,     [src]
    impl<T> BorrowMut<T> for T where
        T: ?Sized,     [src]
    impl<T> From<T> for T[src]
    impl<T, U> Into<U> for T where
        U: From<T>,     [src]
    impl<T> Spanned for T where
        T: Spanned + ?Sized,     [src]
    impl<T> ToOwned for T where
        T: Clone,     [src]
    type Owned = T
    The resulting type after obtaining ownership.
    
-
    impl<T> ToOwned for T where
        T: Clone,     [src]
    type Owned = T
    The resulting type after obtaining ownership.
    
+
    impl<T, U> TryFrom<U> for T where
        U: Into<T>,     [src]
    type Error = Infallible
    The type returned in the event of a conversion error.
    
-
    impl<T, U> TryInto<U> for T where
        U: TryFrom<T>,     [src]
    type Error = <U as TryFrom<T>>::Error
    The type returned in the event of a conversion error.
    
-
    
\ No newline at end of file
+

    impl<T, U> TryFrom<U> for T where
        U: Into<T>,     [src]

    type Error = Infallible

    The type returned in the event of a conversion error.

    +

    impl<T, U> TryInto<U> for T where
        U: TryFrom<T>,     [src]

    type Error = <U as TryFrom<T>>::Error

    The type returned in the event of a conversion error.

    +
    + \ No newline at end of file diff --git a/syn/token/struct.Colon.html b/syn/token/struct.Colon.html index 68e58ed..7620bab 100644 --- a/syn/token/struct.Colon.html +++ b/syn/token/struct.Colon.html @@ -1,40 +1,41 @@ -syn::token::Colon - Rust +syn::token::Colon - Rust -

    [−][src]Struct syn::token::Colon

    #[repr(C)]pub struct Colon {
+
    Struct syn::token::Colon[−][src]
    #[repr(C)]pub struct Colon {
     pub spans: [Span; 1],
 }
    :
    
-
    Don't try to remember the name of this type — use the
+
    Don’t try to remember the name of this type — use the
 Token! macro instead.
    
 
    
                        Fields
    spans: [Span; 1]
    Trait Implementations
    impl Clone for Colon[src]
    impl Copy for Colon[src]
    impl Debug for Colon[src]
    impl Default for Colon[src]
    impl Default for Colon[src]
    impl Deref for Colon[src]
    type Target = WithSpan
    The resulting type after dereferencing.
    
 
    impl DerefMut for Colon[src]
    impl Eq for Colon[src]
    impl Hash for Colon[src]
    impl Parse for Colon[src]
    impl PartialEq<Colon> for Colon[src]
    impl ToTokens for Colon[src]
    impl Token for Colon[src]
    Auto Trait Implementations
    Blanket Implementations
    impl<T> Any for T where
        T: 'static + ?Sized,     [src]
    impl<T> Borrow<T> for T where
        T: ?Sized,     [src]
    impl<T> BorrowMut<T> for T where
        T: ?Sized,     [src]
    impl<T> From<T> for T[src]
    impl<T, U> Into<U> for T where
        U: From<T>,     [src]
    impl Token for Colon[src]
    Auto Trait Implementations
    impl RefUnwindSafe for Colon
    impl !Send for Colon
    impl !Sync for Colon
    impl Unpin for Colon
    impl UnwindSafe for Colon
    Blanket Implementations
    impl<T> Any for T where
        T: 'static + ?Sized,     [src]
    impl<T> Borrow<T> for T where
        T: ?Sized,     [src]
    impl<T> BorrowMut<T> for T where
        T: ?Sized,     [src]
    impl<T> From<T> for T[src]
    impl<T, U> Into<U> for T where
        U: From<T>,     [src]
    impl<T> Spanned for T where
        T: Spanned + ?Sized,     [src]
    impl<T> ToOwned for T where
        T: Clone,     [src]
    type Owned = T
    The resulting type after obtaining ownership.
    
-
    impl<T> ToOwned for T where
        T: Clone,     [src]
    type Owned = T
    The resulting type after obtaining ownership.
    
+
    impl<T, U> TryFrom<U> for T where
        U: Into<T>,     [src]
    type Error = Infallible
    The type returned in the event of a conversion error.
    
-
    impl<T, U> TryInto<U> for T where
        U: TryFrom<T>,     [src]
    type Error = <U as TryFrom<T>>::Error
    The type returned in the event of a conversion error.
    
-
    
\ No newline at end of file
+

    impl<T, U> TryFrom<U> for T where
        U: Into<T>,     [src]

    type Error = Infallible

    The type returned in the event of a conversion error.

    +

    impl<T, U> TryInto<U> for T where
        U: TryFrom<T>,     [src]

    type Error = <U as TryFrom<T>>::Error

    The type returned in the event of a conversion error.

    +
    + \ No newline at end of file diff --git a/syn/token/struct.Colon2.html b/syn/token/struct.Colon2.html index 0081c72..c1919e1 100644 --- a/syn/token/struct.Colon2.html +++ b/syn/token/struct.Colon2.html @@ -1,37 +1,38 @@ -syn::token::Colon2 - Rust +syn::token::Colon2 - Rust -

    [−][src]Struct syn::token::Colon2

    #[repr(C)]pub struct Colon2 {
+
    Struct syn::token::Colon2[−][src]
    #[repr(C)]pub struct Colon2 {
     pub spans: [Span; 2],
 }
    ::
    
-
    Don't try to remember the name of this type — use the
+
    Don’t try to remember the name of this type — use the
 Token! macro instead.
    
 
    
                        Fields
    spans: [Span; 2]
    Trait Implementations
    impl Clone for Colon2[src]
    impl Copy for Colon2[src]
    impl Debug for Colon2[src]
    impl Default for Colon2[src]
    impl Default for Colon2[src]
    impl Eq for Colon2[src]
    impl Hash for Colon2[src]
    impl Parse for Colon2[src]
    impl PartialEq<Colon2> for Colon2[src]
    impl ToTokens for Colon2[src]
    impl Token for Colon2[src]
    Auto Trait Implementations
    Blanket Implementations
    impl<T> Any for T where
        T: 'static + ?Sized,     [src]
    impl<T> Borrow<T> for T where
        T: ?Sized,     [src]
    impl<T> BorrowMut<T> for T where
        T: ?Sized,     [src]
    impl<T> From<T> for T[src]
    impl<T, U> Into<U> for T where
        U: From<T>,     [src]
    impl Token for Colon2[src]
    Auto Trait Implementations
    impl RefUnwindSafe for Colon2
    impl !Send for Colon2
    impl !Sync for Colon2
    impl Unpin for Colon2
    impl UnwindSafe for Colon2
    Blanket Implementations
    impl<T> Any for T where
        T: 'static + ?Sized,     [src]
    impl<T> Borrow<T> for T where
        T: ?Sized,     [src]
    impl<T> BorrowMut<T> for T where
        T: ?Sized,     [src]
    impl<T> From<T> for T[src]
    impl<T, U> Into<U> for T where
        U: From<T>,     [src]
    impl<T> Spanned for T where
        T: Spanned + ?Sized,     [src]
    impl<T> ToOwned for T where
        T: Clone,     [src]
    type Owned = T
    The resulting type after obtaining ownership.
    
-
    impl<T> ToOwned for T where
        T: Clone,     [src]
    type Owned = T
    The resulting type after obtaining ownership.
    
+
    impl<T, U> TryFrom<U> for T where
        U: Into<T>,     [src]
    type Error = Infallible
    The type returned in the event of a conversion error.
    
-
    impl<T, U> TryInto<U> for T where
        U: TryFrom<T>,     [src]
    type Error = <U as TryFrom<T>>::Error
    The type returned in the event of a conversion error.
    
-
    
\ No newline at end of file
+

    impl<T, U> TryFrom<U> for T where
        U: Into<T>,     [src]

    type Error = Infallible

    The type returned in the event of a conversion error.

    +

    impl<T, U> TryInto<U> for T where
        U: TryFrom<T>,     [src]

    type Error = <U as TryFrom<T>>::Error

    The type returned in the event of a conversion error.

    +
    + \ No newline at end of file diff --git a/syn/token/struct.Comma.html b/syn/token/struct.Comma.html index 368c3e1..9e5428a 100644 --- a/syn/token/struct.Comma.html +++ b/syn/token/struct.Comma.html @@ -1,40 +1,41 @@ -syn::token::Comma - Rust +syn::token::Comma - Rust -

    [−][src]Struct syn::token::Comma

    #[repr(C)]pub struct Comma {
+
    Struct syn::token::Comma[−][src]
    #[repr(C)]pub struct Comma {
     pub spans: [Span; 1],
 }
    ,
    
-
    Don't try to remember the name of this type — use the
+
    Don’t try to remember the name of this type — use the
 Token! macro instead.
    
 
    
                        Fields
    spans: [Span; 1]
    Trait Implementations
    impl Clone for Comma[src]
    impl Copy for Comma[src]
    impl Debug for Comma[src]
    impl Default for Comma[src]
    impl Default for Comma[src]
    impl Deref for Comma[src]
    type Target = WithSpan
    The resulting type after dereferencing.
    
 
    impl DerefMut for Comma[src]
    impl Eq for Comma[src]
    impl Hash for Comma[src]
    impl Parse for Comma[src]
    impl PartialEq<Comma> for Comma[src]
    impl ToTokens for Comma[src]
    impl Token for Comma[src]
    Auto Trait Implementations
    Blanket Implementations
    impl<T> Any for T where
        T: 'static + ?Sized,     [src]
    impl<T> Borrow<T> for T where
        T: ?Sized,     [src]
    impl<T> BorrowMut<T> for T where
        T: ?Sized,     [src]
    impl<T> From<T> for T[src]
    impl<T, U> Into<U> for T where
        U: From<T>,     [src]
    impl Token for Comma[src]
    Auto Trait Implementations
    impl RefUnwindSafe for Comma
    impl !Send for Comma
    impl !Sync for Comma
    impl Unpin for Comma
    impl UnwindSafe for Comma
    Blanket Implementations
    impl<T> Any for T where
        T: 'static + ?Sized,     [src]
    impl<T> Borrow<T> for T where
        T: ?Sized,     [src]
    impl<T> BorrowMut<T> for T where
        T: ?Sized,     [src]
    impl<T> From<T> for T[src]
    impl<T, U> Into<U> for T where
        U: From<T>,     [src]
    impl<T> Spanned for T where
        T: Spanned + ?Sized,     [src]
    impl<T> ToOwned for T where
        T: Clone,     [src]
    type Owned = T
    The resulting type after obtaining ownership.
    
-
    impl<T> ToOwned for T where
        T: Clone,     [src]
    type Owned = T
    The resulting type after obtaining ownership.
    
+
    impl<T, U> TryFrom<U> for T where
        U: Into<T>,     [src]
    type Error = Infallible
    The type returned in the event of a conversion error.
    
-
    impl<T, U> TryInto<U> for T where
        U: TryFrom<T>,     [src]
    type Error = <U as TryFrom<T>>::Error
    The type returned in the event of a conversion error.
    
-
    
\ No newline at end of file
+

    impl<T, U> TryFrom<U> for T where
        U: Into<T>,     [src]

    type Error = Infallible

    The type returned in the event of a conversion error.

    +

    impl<T, U> TryInto<U> for T where
        U: TryFrom<T>,     [src]

    type Error = <U as TryFrom<T>>::Error

    The type returned in the event of a conversion error.

    +
    + \ No newline at end of file diff --git a/syn/token/struct.Const.html b/syn/token/struct.Const.html index 0379996..ca52ba0 100644 --- a/syn/token/struct.Const.html +++ b/syn/token/struct.Const.html @@ -1,37 +1,38 @@ -syn::token::Const - Rust +syn::token::Const - Rust -

    [−][src]Struct syn::token::Const

    pub struct Const {
+
    Struct syn::token::Const[−][src]
    pub struct Const {
     pub span: Span,
 }
    const
    
-
    Don't try to remember the name of this type — use the
+
    Don’t try to remember the name of this type — use the
 Token! macro instead.
    
 
    
                        Fields
    span: Span
    Trait Implementations
    impl Clone for Const[src]
    impl Copy for Const[src]
    impl Debug for Const[src]
    impl Default for Const[src]
    impl Default for Const[src]
    impl Eq for Const[src]
    impl Hash for Const[src]
    impl Parse for Const[src]
    impl PartialEq<Const> for Const[src]
    impl ToTokens for Const[src]
    impl Token for Const[src]
    Auto Trait Implementations
    Blanket Implementations
    impl<T> Any for T where
        T: 'static + ?Sized,     [src]
    impl<T> Borrow<T> for T where
        T: ?Sized,     [src]
    impl<T> BorrowMut<T> for T where
        T: ?Sized,     [src]
    impl<T> From<T> for T[src]
    impl<T, U> Into<U> for T where
        U: From<T>,     [src]
    impl Token for Const[src]
    Auto Trait Implementations
    impl RefUnwindSafe for Const
    impl !Send for Const
    impl !Sync for Const
    impl Unpin for Const
    impl UnwindSafe for Const
    Blanket Implementations
    impl<T> Any for T where
        T: 'static + ?Sized,     [src]
    impl<T> Borrow<T> for T where
        T: ?Sized,     [src]
    impl<T> BorrowMut<T> for T where
        T: ?Sized,     [src]
    impl<T> From<T> for T[src]
    impl<T, U> Into<U> for T where
        U: From<T>,     [src]
    impl<T> Spanned for T where
        T: Spanned + ?Sized,     [src]
    impl<T> ToOwned for T where
        T: Clone,     [src]
    type Owned = T
    The resulting type after obtaining ownership.
    
-
    impl<T> ToOwned for T where
        T: Clone,     [src]
    type Owned = T
    The resulting type after obtaining ownership.
    
+
    impl<T, U> TryFrom<U> for T where
        U: Into<T>,     [src]
    type Error = Infallible
    The type returned in the event of a conversion error.
    
-
    impl<T, U> TryInto<U> for T where
        U: TryFrom<T>,     [src]
    type Error = <U as TryFrom<T>>::Error
    The type returned in the event of a conversion error.
    
-
    
\ No newline at end of file
+

    impl<T, U> TryFrom<U> for T where
        U: Into<T>,     [src]

    type Error = Infallible

    The type returned in the event of a conversion error.

    +

    impl<T, U> TryInto<U> for T where
        U: TryFrom<T>,     [src]

    type Error = <U as TryFrom<T>>::Error

    The type returned in the event of a conversion error.

    +
    + \ No newline at end of file diff --git a/syn/token/struct.Continue.html b/syn/token/struct.Continue.html index 1632877..1bf44fe 100644 --- a/syn/token/struct.Continue.html +++ b/syn/token/struct.Continue.html @@ -1,37 +1,38 @@ -syn::token::Continue - Rust +syn::token::Continue - Rust -

    [−][src]Struct syn::token::Continue

    pub struct Continue {
+
    Struct syn::token::Continue[−][src]
    pub struct Continue {
     pub span: Span,
 }
    continue
    
-
    Don't try to remember the name of this type — use the
+
    Don’t try to remember the name of this type — use the
 Token! macro instead.
    
 
    
                        Fields
    span: Span
    Trait Implementations
    impl Clone for Continue[src]
    impl Copy for Continue[src]
    impl Debug for Continue[src]
    impl Default for Continue[src]
    impl Default for Continue[src]
    impl Eq for Continue[src]
    impl Hash for Continue[src]
    impl Parse for Continue[src]
    impl PartialEq<Continue> for Continue[src]
    impl ToTokens for Continue[src]
    impl Token for Continue[src]
    Auto Trait Implementations
    Blanket Implementations
    impl<T> Any for T where
        T: 'static + ?Sized,     [src]
    impl<T> Borrow<T> for T where
        T: ?Sized,     [src]
    impl<T> BorrowMut<T> for T where
        T: ?Sized,     [src]
    impl<T> From<T> for T[src]
    impl<T, U> Into<U> for T where
        U: From<T>,     [src]
    impl Token for Continue[src]
    Auto Trait Implementations
    impl RefUnwindSafe for Continue
    impl !Send for Continue
    impl !Sync for Continue
    impl Unpin for Continue
    impl UnwindSafe for Continue
    Blanket Implementations
    impl<T> Any for T where
        T: 'static + ?Sized,     [src]
    impl<T> Borrow<T> for T where
        T: ?Sized,     [src]
    impl<T> BorrowMut<T> for T where
        T: ?Sized,     [src]
    impl<T> From<T> for T[src]
    impl<T, U> Into<U> for T where
        U: From<T>,     [src]
    impl<T> Spanned for T where
        T: Spanned + ?Sized,     [src]
    impl<T> ToOwned for T where
        T: Clone,     [src]
    type Owned = T
    The resulting type after obtaining ownership.
    
-
    impl<T> ToOwned for T where
        T: Clone,     [src]
    type Owned = T
    The resulting type after obtaining ownership.
    
+
    impl<T, U> TryFrom<U> for T where
        U: Into<T>,     [src]
    type Error = Infallible
    The type returned in the event of a conversion error.
    
-
    impl<T, U> TryInto<U> for T where
        U: TryFrom<T>,     [src]
    type Error = <U as TryFrom<T>>::Error
    The type returned in the event of a conversion error.
    
-
    
\ No newline at end of file
+

    impl<T, U> TryFrom<U> for T where
        U: Into<T>,     [src]

    type Error = Infallible

    The type returned in the event of a conversion error.

    +

    impl<T, U> TryInto<U> for T where
        U: TryFrom<T>,     [src]

    type Error = <U as TryFrom<T>>::Error

    The type returned in the event of a conversion error.

    +
    + \ No newline at end of file diff --git a/syn/token/struct.Crate.html b/syn/token/struct.Crate.html index d5985b7..3f352b1 100644 --- a/syn/token/struct.Crate.html +++ b/syn/token/struct.Crate.html @@ -1,38 +1,39 @@ -syn::token::Crate - Rust +syn::token::Crate - Rust -

    [−][src]Struct syn::token::Crate

    pub struct Crate {
+
    Struct syn::token::Crate[−][src]
    pub struct Crate {
     pub span: Span,
 }
    crate
    
-
    Don't try to remember the name of this type — use the
+
    Don’t try to remember the name of this type — use the
 Token! macro instead.
    
 
    
                        Fields
    span: Span
    Trait Implementations
    impl Clone for Crate[src]
    impl Copy for Crate[src]
    impl Debug for Crate[src]
    impl Default for Crate[src]
    impl Default for Crate[src]
    impl Eq for Crate[src]
    impl From<Crate> for Ident[src]
    impl Hash for Crate[src]
    impl Parse for Crate[src]
    impl PartialEq<Crate> for Crate[src]
    impl ToTokens for Crate[src]
    impl Token for Crate[src]
    Auto Trait Implementations
    Blanket Implementations
    impl<T> Any for T where
        T: 'static + ?Sized,     [src]
    impl<T> Borrow<T> for T where
        T: ?Sized,     [src]
    impl<T> BorrowMut<T> for T where
        T: ?Sized,     [src]
    impl<T> From<T> for T[src]
    impl<T, U> Into<U> for T where
        U: From<T>,     [src]
    impl Token for Crate[src]
    Auto Trait Implementations
    impl RefUnwindSafe for Crate
    impl !Send for Crate
    impl !Sync for Crate
    impl Unpin for Crate
    impl UnwindSafe for Crate
    Blanket Implementations
    impl<T> Any for T where
        T: 'static + ?Sized,     [src]
    impl<T> Borrow<T> for T where
        T: ?Sized,     [src]
    impl<T> BorrowMut<T> for T where
        T: ?Sized,     [src]
    impl<T> From<T> for T[src]
    impl<T, U> Into<U> for T where
        U: From<T>,     [src]
    impl<T> Spanned for T where
        T: Spanned + ?Sized,     [src]
    impl<T> ToOwned for T where
        T: Clone,     [src]
    type Owned = T
    The resulting type after obtaining ownership.
    
-
    impl<T> ToOwned for T where
        T: Clone,     [src]
    type Owned = T
    The resulting type after obtaining ownership.
    
+
    impl<T, U> TryFrom<U> for T where
        U: Into<T>,     [src]
    type Error = Infallible
    The type returned in the event of a conversion error.
    
-
    impl<T, U> TryInto<U> for T where
        U: TryFrom<T>,     [src]
    type Error = <U as TryFrom<T>>::Error
    The type returned in the event of a conversion error.
    
-
    
\ No newline at end of file
+

    impl<T, U> TryFrom<U> for T where
        U: Into<T>,     [src]

    type Error = Infallible

    The type returned in the event of a conversion error.

    +

    impl<T, U> TryInto<U> for T where
        U: TryFrom<T>,     [src]

    type Error = <U as TryFrom<T>>::Error

    The type returned in the event of a conversion error.

    +
    + \ No newline at end of file diff --git a/syn/token/struct.Default.html b/syn/token/struct.Default.html index 751add2..a20e959 100644 --- a/syn/token/struct.Default.html +++ b/syn/token/struct.Default.html @@ -1,37 +1,38 @@ -syn::token::Default - Rust +syn::token::Default - Rust -

    [−][src]Struct syn::token::Default

    pub struct Default {
+
    Struct syn::token::Default[−][src]
    pub struct Default {
     pub span: Span,
 }
    default
    
-
    Don't try to remember the name of this type — use the
+
    Don’t try to remember the name of this type — use the
 Token! macro instead.
    
 
    
                        Fields
    span: Span
    Trait Implementations
    impl Clone for Default[src]
    impl Copy for Default[src]
    impl Debug for Default[src]
    impl Default for Default[src]
    impl Default for Default[src]
    impl Eq for Default[src]
    impl Hash for Default[src]
    impl Parse for Default[src]
    impl PartialEq<Default> for Default[src]
    impl ToTokens for Default[src]
    impl Token for Default[src]
    Auto Trait Implementations
    Blanket Implementations
    impl<T> Any for T where
        T: 'static + ?Sized,     [src]
    impl<T> Borrow<T> for T where
        T: ?Sized,     [src]
    impl<T> BorrowMut<T> for T where
        T: ?Sized,     [src]
    impl<T> From<T> for T[src]
    impl<T, U> Into<U> for T where
        U: From<T>,     [src]
    impl Token for Default[src]
    Auto Trait Implementations
    impl RefUnwindSafe for Default
    impl !Send for Default
    impl !Sync for Default
    impl Unpin for Default
    impl UnwindSafe for Default
    Blanket Implementations
    impl<T> Any for T where
        T: 'static + ?Sized,     [src]
    impl<T> Borrow<T> for T where
        T: ?Sized,     [src]
    impl<T> BorrowMut<T> for T where
        T: ?Sized,     [src]
    impl<T> From<T> for T[src]
    impl<T, U> Into<U> for T where
        U: From<T>,     [src]
    impl<T> Spanned for T where
        T: Spanned + ?Sized,     [src]
    impl<T> ToOwned for T where
        T: Clone,     [src]
    type Owned = T
    The resulting type after obtaining ownership.
    
-
    impl<T> ToOwned for T where
        T: Clone,     [src]
    type Owned = T
    The resulting type after obtaining ownership.
    
+
    impl<T, U> TryFrom<U> for T where
        U: Into<T>,     [src]
    type Error = Infallible
    The type returned in the event of a conversion error.
    
-
    impl<T, U> TryInto<U> for T where
        U: TryFrom<T>,     [src]
    type Error = <U as TryFrom<T>>::Error
    The type returned in the event of a conversion error.
    
-
    
\ No newline at end of file
+

    impl<T, U> TryFrom<U> for T where
        U: Into<T>,     [src]

    type Error = Infallible

    The type returned in the event of a conversion error.

    +

    impl<T, U> TryInto<U> for T where
        U: TryFrom<T>,     [src]

    type Error = <U as TryFrom<T>>::Error

    The type returned in the event of a conversion error.

    +
    + \ No newline at end of file diff --git a/syn/token/struct.Div.html b/syn/token/struct.Div.html index 4bbd49b..deff89e 100644 --- a/syn/token/struct.Div.html +++ b/syn/token/struct.Div.html @@ -1,40 +1,41 @@ -syn::token::Div - Rust +syn::token::Div - Rust -

    [−][src]Struct syn::token::Div

    #[repr(C)]pub struct Div {
+
    Struct syn::token::Div[−][src]
    #[repr(C)]pub struct Div {
     pub spans: [Span; 1],
 }
    /
    
-
    Don't try to remember the name of this type — use the
+
    Don’t try to remember the name of this type — use the
 Token! macro instead.
    
 
    
                        Fields
    spans: [Span; 1]
    Trait Implementations
    impl Clone for Div[src]
    impl Copy for Div[src]
    impl Debug for Div[src]
    impl Default for Div[src]
    impl Default for Div[src]
    impl Deref for Div[src]
    type Target = WithSpan
    The resulting type after dereferencing.
    
 
    impl DerefMut for Div[src]
    impl Eq for Div[src]
    impl Hash for Div[src]
    impl Parse for Div[src]
    impl PartialEq<Div> for Div[src]
    impl ToTokens for Div[src]
    impl Token for Div[src]
    Auto Trait Implementations
    impl RefUnwindSafe for Div[src]
    impl !Send for Div[src]
    impl !Sync for Div[src]
    impl Unpin for Div[src]
    impl UnwindSafe for Div[src]
    Blanket Implementations
    impl<T> Any for T where
        T: 'static + ?Sized,     [src]
    impl<T> Borrow<T> for T where
        T: ?Sized,     [src]
    impl<T> BorrowMut<T> for T where
        T: ?Sized,     [src]
    impl<T> From<T> for T[src]
    impl<T, U> Into<U> for T where
        U: From<T>,     [src]
    impl Token for Div[src]
    Auto Trait Implementations
    impl RefUnwindSafe for Div
    impl !Send for Div
    impl !Sync for Div
    impl Unpin for Div
    impl UnwindSafe for Div
    Blanket Implementations
    impl<T> Any for T where
        T: 'static + ?Sized,     [src]
    impl<T> Borrow<T> for T where
        T: ?Sized,     [src]
    impl<T> BorrowMut<T> for T where
        T: ?Sized,     [src]
    impl<T> From<T> for T[src]
    impl<T, U> Into<U> for T where
        U: From<T>,     [src]
    impl<T> Spanned for T where
        T: Spanned + ?Sized,     [src]
    impl<T> ToOwned for T where
        T: Clone,     [src]
    type Owned = T
    The resulting type after obtaining ownership.
    
-
    impl<T> ToOwned for T where
        T: Clone,     [src]
    type Owned = T
    The resulting type after obtaining ownership.
    
+
    impl<T, U> TryFrom<U> for T where
        U: Into<T>,     [src]
    type Error = Infallible
    The type returned in the event of a conversion error.
    
-
    impl<T, U> TryInto<U> for T where
        U: TryFrom<T>,     [src]
    type Error = <U as TryFrom<T>>::Error
    The type returned in the event of a conversion error.
    
-
    
\ No newline at end of file
+

    impl<T, U> TryFrom<U> for T where
        U: Into<T>,     [src]

    type Error = Infallible

    The type returned in the event of a conversion error.

    +

    impl<T, U> TryInto<U> for T where
        U: TryFrom<T>,     [src]

    type Error = <U as TryFrom<T>>::Error

    The type returned in the event of a conversion error.

    +
    + \ No newline at end of file diff --git a/syn/token/struct.DivEq.html b/syn/token/struct.DivEq.html index ae37d6c..07ae9e4 100644 --- a/syn/token/struct.DivEq.html +++ b/syn/token/struct.DivEq.html @@ -1,37 +1,38 @@ -syn::token::DivEq - Rust +syn::token::DivEq - Rust -

    [−][src]Struct syn::token::DivEq

    #[repr(C)]pub struct DivEq {
+
    Struct syn::token::DivEq[−][src]
    #[repr(C)]pub struct DivEq {
     pub spans: [Span; 2],
 }
    /=
    
-
    Don't try to remember the name of this type — use the
+
    Don’t try to remember the name of this type — use the
 Token! macro instead.
    
 
    
                        Fields
    spans: [Span; 2]
    Trait Implementations
    impl Clone for DivEq[src]
    impl Copy for DivEq[src]
    impl Debug for DivEq[src]
    impl Default for DivEq[src]
    impl Default for DivEq[src]
    impl Eq for DivEq[src]
    impl Hash for DivEq[src]
    impl Parse for DivEq[src]
    impl PartialEq<DivEq> for DivEq[src]
    impl ToTokens for DivEq[src]
    impl Token for DivEq[src]
    Auto Trait Implementations
    Blanket Implementations
    impl<T> Any for T where
        T: 'static + ?Sized,     [src]
    impl<T> Borrow<T> for T where
        T: ?Sized,     [src]
    impl<T> BorrowMut<T> for T where
        T: ?Sized,     [src]
    impl<T> From<T> for T[src]
    impl<T, U> Into<U> for T where
        U: From<T>,     [src]
    impl Token for DivEq[src]
    Auto Trait Implementations
    impl RefUnwindSafe for DivEq
    impl !Send for DivEq
    impl !Sync for DivEq
    impl Unpin for DivEq
    impl UnwindSafe for DivEq
    Blanket Implementations
    impl<T> Any for T where
        T: 'static + ?Sized,     [src]
    impl<T> Borrow<T> for T where
        T: ?Sized,     [src]
    impl<T> BorrowMut<T> for T where
        T: ?Sized,     [src]
    impl<T> From<T> for T[src]
    impl<T, U> Into<U> for T where
        U: From<T>,     [src]
    impl<T> Spanned for T where
        T: Spanned + ?Sized,     [src]
    impl<T> ToOwned for T where
        T: Clone,     [src]
    type Owned = T
    The resulting type after obtaining ownership.
    
-
    impl<T> ToOwned for T where
        T: Clone,     [src]
    type Owned = T
    The resulting type after obtaining ownership.
    
+
    impl<T, U> TryFrom<U> for T where
        U: Into<T>,     [src]
    type Error = Infallible
    The type returned in the event of a conversion error.
    
-
    impl<T, U> TryInto<U> for T where
        U: TryFrom<T>,     [src]
    type Error = <U as TryFrom<T>>::Error
    The type returned in the event of a conversion error.
    
-
    
\ No newline at end of file
+

    impl<T, U> TryFrom<U> for T where
        U: Into<T>,     [src]

    type Error = Infallible

    The type returned in the event of a conversion error.

    +

    impl<T, U> TryInto<U> for T where
        U: TryFrom<T>,     [src]

    type Error = <U as TryFrom<T>>::Error

    The type returned in the event of a conversion error.

    +
    + \ No newline at end of file diff --git a/syn/token/struct.Do.html b/syn/token/struct.Do.html index 880c8c5..50745ff 100644 --- a/syn/token/struct.Do.html +++ b/syn/token/struct.Do.html @@ -1,37 +1,38 @@ -syn::token::Do - Rust +syn::token::Do - Rust -

    [−][src]Struct syn::token::Do

    pub struct Do {
+
    Struct syn::token::Do[−][src]
    pub struct Do {
     pub span: Span,
 }
    do
    
-
    Don't try to remember the name of this type — use the
+
    Don’t try to remember the name of this type — use the
 Token! macro instead.
    
 
    
                        Fields
    span: Span
    Trait Implementations
    impl Clone for Do[src]
    impl Copy for Do[src]
    impl Debug for Do[src]
    impl Default for Do[src]
    impl Default for Do[src]
    impl Eq for Do[src]
    impl Hash for Do[src]
    impl Parse for Do[src]
    impl PartialEq<Do> for Do[src]
    impl ToTokens for Do[src]
    impl Token for Do[src]
    Auto Trait Implementations
    impl RefUnwindSafe for Do[src]
    impl !Send for Do[src]
    impl !Sync for Do[src]
    impl Unpin for Do[src]
    impl UnwindSafe for Do[src]
    Blanket Implementations
    impl<T> Any for T where
        T: 'static + ?Sized,     [src]
    impl<T> Borrow<T> for T where
        T: ?Sized,     [src]
    impl<T> BorrowMut<T> for T where
        T: ?Sized,     [src]
    impl<T> From<T> for T[src]
    impl<T, U> Into<U> for T where
        U: From<T>,     [src]
    impl Token for Do[src]
    Auto Trait Implementations
    impl RefUnwindSafe for Do
    impl !Send for Do
    impl !Sync for Do
    impl Unpin for Do
    impl UnwindSafe for Do
    Blanket Implementations
    impl<T> Any for T where
        T: 'static + ?Sized,     [src]
    impl<T> Borrow<T> for T where
        T: ?Sized,     [src]
    impl<T> BorrowMut<T> for T where
        T: ?Sized,     [src]
    impl<T> From<T> for T[src]
    impl<T, U> Into<U> for T where
        U: From<T>,     [src]
    impl<T> Spanned for T where
        T: Spanned + ?Sized,     [src]
    impl<T> ToOwned for T where
        T: Clone,     [src]
    type Owned = T
    The resulting type after obtaining ownership.
    
-
    impl<T> ToOwned for T where
        T: Clone,     [src]
    type Owned = T
    The resulting type after obtaining ownership.
    
+
    impl<T, U> TryFrom<U> for T where
        U: Into<T>,     [src]
    type Error = Infallible
    The type returned in the event of a conversion error.
    
-
    impl<T, U> TryInto<U> for T where
        U: TryFrom<T>,     [src]
    type Error = <U as TryFrom<T>>::Error
    The type returned in the event of a conversion error.
    
-
    
\ No newline at end of file
+

    impl<T, U> TryFrom<U> for T where
        U: Into<T>,     [src]

    type Error = Infallible

    The type returned in the event of a conversion error.

    +

    impl<T, U> TryInto<U> for T where
        U: TryFrom<T>,     [src]

    type Error = <U as TryFrom<T>>::Error

    The type returned in the event of a conversion error.

    +
    + \ No newline at end of file diff --git a/syn/token/struct.Dollar.html b/syn/token/struct.Dollar.html index af2d94c..fffa52a 100644 --- a/syn/token/struct.Dollar.html +++ b/syn/token/struct.Dollar.html @@ -1,40 +1,41 @@ -syn::token::Dollar - Rust +syn::token::Dollar - Rust -

    [−][src]Struct syn::token::Dollar

    #[repr(C)]pub struct Dollar {
+
    Struct syn::token::Dollar[−][src]
    #[repr(C)]pub struct Dollar {
     pub spans: [Span; 1],
 }
    $
    
-
    Don't try to remember the name of this type — use the
+
    Don’t try to remember the name of this type — use the
 Token! macro instead.
    
 
    
                        Fields
    spans: [Span; 1]
    Trait Implementations
    impl Clone for Dollar[src]
    impl Copy for Dollar[src]
    impl Debug for Dollar[src]
    impl Default for Dollar[src]
    impl Default for Dollar[src]
    impl Deref for Dollar[src]
    type Target = WithSpan
    The resulting type after dereferencing.
    
 
    impl DerefMut for Dollar[src]
    impl Eq for Dollar[src]
    impl Hash for Dollar[src]
    impl Parse for Dollar[src]
    impl PartialEq<Dollar> for Dollar[src]
    impl ToTokens for Dollar[src]
    impl Token for Dollar[src]
    Auto Trait Implementations
    Blanket Implementations
    impl<T> Any for T where
        T: 'static + ?Sized,     [src]
    impl<T> Borrow<T> for T where
        T: ?Sized,     [src]
    impl<T> BorrowMut<T> for T where
        T: ?Sized,     [src]
    impl<T> From<T> for T[src]
    impl<T, U> Into<U> for T where
        U: From<T>,     [src]
    impl Token for Dollar[src]
    Auto Trait Implementations
    impl RefUnwindSafe for Dollar
    impl !Send for Dollar
    impl !Sync for Dollar
    impl Unpin for Dollar
    impl UnwindSafe for Dollar
    Blanket Implementations
    impl<T> Any for T where
        T: 'static + ?Sized,     [src]
    impl<T> Borrow<T> for T where
        T: ?Sized,     [src]
    impl<T> BorrowMut<T> for T where
        T: ?Sized,     [src]
    impl<T> From<T> for T[src]
    impl<T, U> Into<U> for T where
        U: From<T>,     [src]
    impl<T> Spanned for T where
        T: Spanned + ?Sized,     [src]
    impl<T> ToOwned for T where
        T: Clone,     [src]
    type Owned = T
    The resulting type after obtaining ownership.
    
-
    impl<T> ToOwned for T where
        T: Clone,     [src]
    type Owned = T
    The resulting type after obtaining ownership.
    
+
    impl<T, U> TryFrom<U> for T where
        U: Into<T>,     [src]
    type Error = Infallible
    The type returned in the event of a conversion error.
    
-
    impl<T, U> TryInto<U> for T where
        U: TryFrom<T>,     [src]
    type Error = <U as TryFrom<T>>::Error
    The type returned in the event of a conversion error.
    
-
    
\ No newline at end of file
+

    impl<T, U> TryFrom<U> for T where
        U: Into<T>,     [src]

    type Error = Infallible

    The type returned in the event of a conversion error.

    +

    impl<T, U> TryInto<U> for T where
        U: TryFrom<T>,     [src]

    type Error = <U as TryFrom<T>>::Error

    The type returned in the event of a conversion error.

    +
    + \ No newline at end of file diff --git a/syn/token/struct.Dot.html b/syn/token/struct.Dot.html index 12e96fd..10874c8 100644 --- a/syn/token/struct.Dot.html +++ b/syn/token/struct.Dot.html @@ -1,40 +1,41 @@ -syn::token::Dot - Rust +syn::token::Dot - Rust -

    [−][src]Struct syn::token::Dot

    #[repr(C)]pub struct Dot {
+
    Struct syn::token::Dot[−][src]
    #[repr(C)]pub struct Dot {
     pub spans: [Span; 1],
 }
    .
    
-
    Don't try to remember the name of this type — use the
+
    Don’t try to remember the name of this type — use the
 Token! macro instead.
    
 
    
                        Fields
    spans: [Span; 1]
    Trait Implementations
    impl Clone for Dot[src]
    impl Copy for Dot[src]
    impl Debug for Dot[src]
    impl Default for Dot[src]
    impl Default for Dot[src]
    impl Deref for Dot[src]
    type Target = WithSpan
    The resulting type after dereferencing.
    
 
    impl DerefMut for Dot[src]
    impl Eq for Dot[src]
    impl Hash for Dot[src]
    impl Parse for Dot[src]
    impl PartialEq<Dot> for Dot[src]
    impl ToTokens for Dot[src]
    impl Token for Dot[src]
    Auto Trait Implementations
    impl RefUnwindSafe for Dot[src]
    impl !Send for Dot[src]
    impl !Sync for Dot[src]
    impl Unpin for Dot[src]
    impl UnwindSafe for Dot[src]
    Blanket Implementations
    impl<T> Any for T where
        T: 'static + ?Sized,     [src]
    impl<T> Borrow<T> for T where
        T: ?Sized,     [src]
    impl<T> BorrowMut<T> for T where
        T: ?Sized,     [src]
    impl<T> From<T> for T[src]
    impl<T, U> Into<U> for T where
        U: From<T>,     [src]
    impl Token for Dot[src]
    Auto Trait Implementations
    impl RefUnwindSafe for Dot
    impl !Send for Dot
    impl !Sync for Dot
    impl Unpin for Dot
    impl UnwindSafe for Dot
    Blanket Implementations
    impl<T> Any for T where
        T: 'static + ?Sized,     [src]
    impl<T> Borrow<T> for T where
        T: ?Sized,     [src]
    impl<T> BorrowMut<T> for T where
        T: ?Sized,     [src]
    impl<T> From<T> for T[src]
    impl<T, U> Into<U> for T where
        U: From<T>,     [src]
    impl<T> Spanned for T where
        T: Spanned + ?Sized,     [src]
    impl<T> ToOwned for T where
        T: Clone,     [src]
    type Owned = T
    The resulting type after obtaining ownership.
    
-
    impl<T> ToOwned for T where
        T: Clone,     [src]
    type Owned = T
    The resulting type after obtaining ownership.
    
+
    impl<T, U> TryFrom<U> for T where
        U: Into<T>,     [src]
    type Error = Infallible
    The type returned in the event of a conversion error.
    
-
    impl<T, U> TryInto<U> for T where
        U: TryFrom<T>,     [src]
    type Error = <U as TryFrom<T>>::Error
    The type returned in the event of a conversion error.
    
-
    
\ No newline at end of file
+

    impl<T, U> TryFrom<U> for T where
        U: Into<T>,     [src]

    type Error = Infallible

    The type returned in the event of a conversion error.

    +

    impl<T, U> TryInto<U> for T where
        U: TryFrom<T>,     [src]

    type Error = <U as TryFrom<T>>::Error

    The type returned in the event of a conversion error.

    +
    + \ No newline at end of file diff --git a/syn/token/struct.Dot2.html b/syn/token/struct.Dot2.html index 3c21692..763fbc6 100644 --- a/syn/token/struct.Dot2.html +++ b/syn/token/struct.Dot2.html @@ -1,37 +1,38 @@ -syn::token::Dot2 - Rust +syn::token::Dot2 - Rust -

    [−][src]Struct syn::token::Dot2

    #[repr(C)]pub struct Dot2 {
+
    Struct syn::token::Dot2[−][src]
    #[repr(C)]pub struct Dot2 {
     pub spans: [Span; 2],
 }
    ..
    
-
    Don't try to remember the name of this type — use the
+
    Don’t try to remember the name of this type — use the
 Token! macro instead.
    
 
    
                        Fields
    spans: [Span; 2]
    Trait Implementations
    impl Clone for Dot2[src]
    impl Copy for Dot2[src]
    impl Debug for Dot2[src]
    impl Default for Dot2[src]
    impl Default for Dot2[src]
    impl Eq for Dot2[src]
    impl Hash for Dot2[src]
    impl Parse for Dot2[src]
    impl PartialEq<Dot2> for Dot2[src]
    impl ToTokens for Dot2[src]
    impl Token for Dot2[src]
    Auto Trait Implementations
    Blanket Implementations
    impl<T> Any for T where
        T: 'static + ?Sized,     [src]
    impl<T> Borrow<T> for T where
        T: ?Sized,     [src]
    impl<T> BorrowMut<T> for T where
        T: ?Sized,     [src]
    impl<T> From<T> for T[src]
    impl<T, U> Into<U> for T where
        U: From<T>,     [src]
    impl Token for Dot2[src]
    Auto Trait Implementations
    impl RefUnwindSafe for Dot2
    impl !Send for Dot2
    impl !Sync for Dot2
    impl Unpin for Dot2
    impl UnwindSafe for Dot2
    Blanket Implementations
    impl<T> Any for T where
        T: 'static + ?Sized,     [src]
    impl<T> Borrow<T> for T where
        T: ?Sized,     [src]
    impl<T> BorrowMut<T> for T where
        T: ?Sized,     [src]
    impl<T> From<T> for T[src]
    impl<T, U> Into<U> for T where
        U: From<T>,     [src]
    impl<T> Spanned for T where
        T: Spanned + ?Sized,     [src]
    impl<T> ToOwned for T where
        T: Clone,     [src]
    type Owned = T
    The resulting type after obtaining ownership.
    
-
    impl<T> ToOwned for T where
        T: Clone,     [src]
    type Owned = T
    The resulting type after obtaining ownership.
    
+
    impl<T, U> TryFrom<U> for T where
        U: Into<T>,     [src]
    type Error = Infallible
    The type returned in the event of a conversion error.
    
-
    impl<T, U> TryInto<U> for T where
        U: TryFrom<T>,     [src]
    type Error = <U as TryFrom<T>>::Error
    The type returned in the event of a conversion error.
    
-
    
\ No newline at end of file
+

    impl<T, U> TryFrom<U> for T where
        U: Into<T>,     [src]

    type Error = Infallible

    The type returned in the event of a conversion error.

    +

    impl<T, U> TryInto<U> for T where
        U: TryFrom<T>,     [src]

    type Error = <U as TryFrom<T>>::Error

    The type returned in the event of a conversion error.

    +
    + \ No newline at end of file diff --git a/syn/token/struct.Dot3.html b/syn/token/struct.Dot3.html index d5169f2..680cc2e 100644 --- a/syn/token/struct.Dot3.html +++ b/syn/token/struct.Dot3.html @@ -1,37 +1,38 @@ -syn::token::Dot3 - Rust +syn::token::Dot3 - Rust -

    [−][src]Struct syn::token::Dot3

    #[repr(C)]pub struct Dot3 {
+
    Struct syn::token::Dot3[−][src]
    #[repr(C)]pub struct Dot3 {
     pub spans: [Span; 3],
 }
    ...
    
-
    Don't try to remember the name of this type — use the
+
    Don’t try to remember the name of this type — use the
 Token! macro instead.
    
 
    
                        Fields
    spans: [Span; 3]
    Trait Implementations
    impl Clone for Dot3[src]
    impl Copy for Dot3[src]
    impl Debug for Dot3[src]
    impl Default for Dot3[src]
    impl Default for Dot3[src]
    impl Eq for Dot3[src]
    impl Hash for Dot3[src]
    impl Parse for Dot3[src]
    impl PartialEq<Dot3> for Dot3[src]
    impl ToTokens for Dot3[src]
    impl Token for Dot3[src]
    Auto Trait Implementations
    Blanket Implementations
    impl<T> Any for T where
        T: 'static + ?Sized,     [src]
    impl<T> Borrow<T> for T where
        T: ?Sized,     [src]
    impl<T> BorrowMut<T> for T where
        T: ?Sized,     [src]
    impl<T> From<T> for T[src]
    impl<T, U> Into<U> for T where
        U: From<T>,     [src]
    impl Token for Dot3[src]
    Auto Trait Implementations
    impl RefUnwindSafe for Dot3
    impl !Send for Dot3
    impl !Sync for Dot3
    impl Unpin for Dot3
    impl UnwindSafe for Dot3
    Blanket Implementations
    impl<T> Any for T where
        T: 'static + ?Sized,     [src]
    impl<T> Borrow<T> for T where
        T: ?Sized,     [src]
    impl<T> BorrowMut<T> for T where
        T: ?Sized,     [src]
    impl<T> From<T> for T[src]
    impl<T, U> Into<U> for T where
        U: From<T>,     [src]
    impl<T> Spanned for T where
        T: Spanned + ?Sized,     [src]
    impl<T> ToOwned for T where
        T: Clone,     [src]
    type Owned = T
    The resulting type after obtaining ownership.
    
-
    impl<T> ToOwned for T where
        T: Clone,     [src]
    type Owned = T
    The resulting type after obtaining ownership.
    
+
    impl<T, U> TryFrom<U> for T where
        U: Into<T>,     [src]
    type Error = Infallible
    The type returned in the event of a conversion error.
    
-
    impl<T, U> TryInto<U> for T where
        U: TryFrom<T>,     [src]
    type Error = <U as TryFrom<T>>::Error
    The type returned in the event of a conversion error.
    
-
    
\ No newline at end of file
+

    impl<T, U> TryFrom<U> for T where
        U: Into<T>,     [src]

    type Error = Infallible

    The type returned in the event of a conversion error.

    +

    impl<T, U> TryInto<U> for T where
        U: TryFrom<T>,     [src]

    type Error = <U as TryFrom<T>>::Error

    The type returned in the event of a conversion error.

    +
    + \ No newline at end of file diff --git a/syn/token/struct.DotDotEq.html b/syn/token/struct.DotDotEq.html index 6121c46..07e07f9 100644 --- a/syn/token/struct.DotDotEq.html +++ b/syn/token/struct.DotDotEq.html @@ -1,37 +1,38 @@ -syn::token::DotDotEq - Rust +syn::token::DotDotEq - Rust -

    [−][src]Struct syn::token::DotDotEq

    #[repr(C)]pub struct DotDotEq {
+
    Struct syn::token::DotDotEq[−][src]
    #[repr(C)]pub struct DotDotEq {
     pub spans: [Span; 3],
 }
    ..=
    
-
    Don't try to remember the name of this type — use the
+
    Don’t try to remember the name of this type — use the
 Token! macro instead.
    
 
    
                        Fields
    spans: [Span; 3]
    Trait Implementations
    impl Clone for DotDotEq[src]
    impl Copy for DotDotEq[src]
    impl Debug for DotDotEq[src]
    impl Default for DotDotEq[src]
    impl Default for DotDotEq[src]
    impl Eq for DotDotEq[src]
    impl Hash for DotDotEq[src]
    impl Parse for DotDotEq[src]
    impl PartialEq<DotDotEq> for DotDotEq[src]
    impl ToTokens for DotDotEq[src]
    impl Token for DotDotEq[src]
    Auto Trait Implementations
    Blanket Implementations
    impl<T> Any for T where
        T: 'static + ?Sized,     [src]
    impl<T> Borrow<T> for T where
        T: ?Sized,     [src]
    impl<T> BorrowMut<T> for T where
        T: ?Sized,     [src]
    impl<T> From<T> for T[src]
    impl<T, U> Into<U> for T where
        U: From<T>,     [src]
    impl Token for DotDotEq[src]
    Auto Trait Implementations
    impl RefUnwindSafe for DotDotEq
    impl !Send for DotDotEq
    impl !Sync for DotDotEq
    impl Unpin for DotDotEq
    impl UnwindSafe for DotDotEq
    Blanket Implementations
    impl<T> Any for T where
        T: 'static + ?Sized,     [src]
    impl<T> Borrow<T> for T where
        T: ?Sized,     [src]
    impl<T> BorrowMut<T> for T where
        T: ?Sized,     [src]
    impl<T> From<T> for T[src]
    impl<T, U> Into<U> for T where
        U: From<T>,     [src]
    impl<T> Spanned for T where
        T: Spanned + ?Sized,     [src]
    impl<T> ToOwned for T where
        T: Clone,     [src]
    type Owned = T
    The resulting type after obtaining ownership.
    
-
    impl<T> ToOwned for T where
        T: Clone,     [src]
    type Owned = T
    The resulting type after obtaining ownership.
    
+
    impl<T, U> TryFrom<U> for T where
        U: Into<T>,     [src]
    type Error = Infallible
    The type returned in the event of a conversion error.
    
-
    impl<T, U> TryInto<U> for T where
        U: TryFrom<T>,     [src]
    type Error = <U as TryFrom<T>>::Error
    The type returned in the event of a conversion error.
    
-
    
\ No newline at end of file
+

    impl<T, U> TryFrom<U> for T where
        U: Into<T>,     [src]

    type Error = Infallible

    The type returned in the event of a conversion error.

    +

    impl<T, U> TryInto<U> for T where
        U: TryFrom<T>,     [src]

    type Error = <U as TryFrom<T>>::Error

    The type returned in the event of a conversion error.

    +
    + \ No newline at end of file diff --git a/syn/token/struct.Dyn.html b/syn/token/struct.Dyn.html index 9c7e8cd..8e1c88c 100644 --- a/syn/token/struct.Dyn.html +++ b/syn/token/struct.Dyn.html @@ -1,37 +1,38 @@ -syn::token::Dyn - Rust +syn::token::Dyn - Rust -

    [−][src]Struct syn::token::Dyn

    pub struct Dyn {
+
    Struct syn::token::Dyn[−][src]
    pub struct Dyn {
     pub span: Span,
 }
    dyn
    
-
    Don't try to remember the name of this type — use the
+
    Don’t try to remember the name of this type — use the
 Token! macro instead.
    
 
    
                        Fields
    span: Span
    Trait Implementations
    impl Clone for Dyn[src]
    impl Copy for Dyn[src]
    impl Debug for Dyn[src]
    impl Default for Dyn[src]
    impl Default for Dyn[src]
    impl Eq for Dyn[src]
    impl Hash for Dyn[src]
    impl Parse for Dyn[src]
    impl PartialEq<Dyn> for Dyn[src]
    impl ToTokens for Dyn[src]
    impl Token for Dyn[src]
    Auto Trait Implementations
    impl RefUnwindSafe for Dyn[src]
    impl !Send for Dyn[src]
    impl !Sync for Dyn[src]
    impl Unpin for Dyn[src]
    impl UnwindSafe for Dyn[src]
    Blanket Implementations
    impl<T> Any for T where
        T: 'static + ?Sized,     [src]
    impl<T> Borrow<T> for T where
        T: ?Sized,     [src]
    impl<T> BorrowMut<T> for T where
        T: ?Sized,     [src]
    impl<T> From<T> for T[src]
    impl<T, U> Into<U> for T where
        U: From<T>,     [src]
    impl Token for Dyn[src]
    Auto Trait Implementations
    impl RefUnwindSafe for Dyn
    impl !Send for Dyn
    impl !Sync for Dyn
    impl Unpin for Dyn
    impl UnwindSafe for Dyn
    Blanket Implementations
    impl<T> Any for T where
        T: 'static + ?Sized,     [src]
    impl<T> Borrow<T> for T where
        T: ?Sized,     [src]
    impl<T> BorrowMut<T> for T where
        T: ?Sized,     [src]
    impl<T> From<T> for T[src]
    impl<T, U> Into<U> for T where
        U: From<T>,     [src]
    impl<T> Spanned for T where
        T: Spanned + ?Sized,     [src]
    impl<T> ToOwned for T where
        T: Clone,     [src]
    type Owned = T
    The resulting type after obtaining ownership.
    
-
    impl<T> ToOwned for T where
        T: Clone,     [src]
    type Owned = T
    The resulting type after obtaining ownership.
    
+
    impl<T, U> TryFrom<U> for T where
        U: Into<T>,     [src]
    type Error = Infallible
    The type returned in the event of a conversion error.
    
-
    impl<T, U> TryInto<U> for T where
        U: TryFrom<T>,     [src]
    type Error = <U as TryFrom<T>>::Error
    The type returned in the event of a conversion error.
    
-
    
\ No newline at end of file
+

    impl<T, U> TryFrom<U> for T where
        U: Into<T>,     [src]

    type Error = Infallible

    The type returned in the event of a conversion error.

    +

    impl<T, U> TryInto<U> for T where
        U: TryFrom<T>,     [src]

    type Error = <U as TryFrom<T>>::Error

    The type returned in the event of a conversion error.

    +
    + \ No newline at end of file diff --git a/syn/token/struct.Else.html b/syn/token/struct.Else.html index e8737fa..4431b6d 100644 --- a/syn/token/struct.Else.html +++ b/syn/token/struct.Else.html @@ -1,37 +1,38 @@ -syn::token::Else - Rust +syn::token::Else - Rust -

    [−][src]Struct syn::token::Else

    pub struct Else {
+
    Struct syn::token::Else[−][src]
    pub struct Else {
     pub span: Span,
 }
    else
    
-
    Don't try to remember the name of this type — use the
+
    Don’t try to remember the name of this type — use the
 Token! macro instead.
    
 
    
                        Fields
    span: Span
    Trait Implementations
    impl Clone for Else[src]
    impl Copy for Else[src]
    impl Debug for Else[src]
    impl Default for Else[src]
    impl Default for Else[src]
    impl Eq for Else[src]
    impl Hash for Else[src]
    impl Parse for Else[src]
    impl PartialEq<Else> for Else[src]
    impl ToTokens for Else[src]
    impl Token for Else[src]
    Auto Trait Implementations
    Blanket Implementations
    impl<T> Any for T where
        T: 'static + ?Sized,     [src]
    impl<T> Borrow<T> for T where
        T: ?Sized,     [src]
    impl<T> BorrowMut<T> for T where
        T: ?Sized,     [src]
    impl<T> From<T> for T[src]
    impl<T, U> Into<U> for T where
        U: From<T>,     [src]
    impl Token for Else[src]
    Auto Trait Implementations
    impl RefUnwindSafe for Else
    impl !Send for Else
    impl !Sync for Else
    impl Unpin for Else
    impl UnwindSafe for Else
    Blanket Implementations
    impl<T> Any for T where
        T: 'static + ?Sized,     [src]
    impl<T> Borrow<T> for T where
        T: ?Sized,     [src]
    impl<T> BorrowMut<T> for T where
        T: ?Sized,     [src]
    impl<T> From<T> for T[src]
    impl<T, U> Into<U> for T where
        U: From<T>,     [src]
    impl<T> Spanned for T where
        T: Spanned + ?Sized,     [src]
    impl<T> ToOwned for T where
        T: Clone,     [src]
    type Owned = T
    The resulting type after obtaining ownership.
    
-
    impl<T> ToOwned for T where
        T: Clone,     [src]
    type Owned = T
    The resulting type after obtaining ownership.
    
+
    impl<T, U> TryFrom<U> for T where
        U: Into<T>,     [src]
    type Error = Infallible
    The type returned in the event of a conversion error.
    
-
    impl<T, U> TryInto<U> for T where
        U: TryFrom<T>,     [src]
    type Error = <U as TryFrom<T>>::Error
    The type returned in the event of a conversion error.
    
-
    
\ No newline at end of file
+

    impl<T, U> TryFrom<U> for T where
        U: Into<T>,     [src]

    type Error = Infallible

    The type returned in the event of a conversion error.

    +

    impl<T, U> TryInto<U> for T where
        U: TryFrom<T>,     [src]

    type Error = <U as TryFrom<T>>::Error

    The type returned in the event of a conversion error.

    +
    + \ No newline at end of file diff --git a/syn/token/struct.Enum.html b/syn/token/struct.Enum.html index 5a04628..71c17bc 100644 --- a/syn/token/struct.Enum.html +++ b/syn/token/struct.Enum.html @@ -1,37 +1,38 @@ -syn::token::Enum - Rust +syn::token::Enum - Rust -

    [−][src]Struct syn::token::Enum

    pub struct Enum {
+
    Struct syn::token::Enum[−][src]
    pub struct Enum {
     pub span: Span,
 }
    enum
    
-
    Don't try to remember the name of this type — use the
+
    Don’t try to remember the name of this type — use the
 Token! macro instead.
    
 
    
                        Fields
    span: Span
    Trait Implementations
    impl Clone for Enum[src]
    impl Copy for Enum[src]
    impl Debug for Enum[src]
    impl Default for Enum[src]
    impl Default for Enum[src]
    impl Eq for Enum[src]
    impl Hash for Enum[src]
    impl Parse for Enum[src]
    impl PartialEq<Enum> for Enum[src]
    impl ToTokens for Enum[src]
    impl Token for Enum[src]
    Auto Trait Implementations
    Blanket Implementations
    impl<T> Any for T where
        T: 'static + ?Sized,     [src]
    impl<T> Borrow<T> for T where
        T: ?Sized,     [src]
    impl<T> BorrowMut<T> for T where
        T: ?Sized,     [src]
    impl<T> From<T> for T[src]
    impl<T, U> Into<U> for T where
        U: From<T>,     [src]
    impl Token for Enum[src]
    Auto Trait Implementations
    impl RefUnwindSafe for Enum
    impl !Send for Enum
    impl !Sync for Enum
    impl Unpin for Enum
    impl UnwindSafe for Enum
    Blanket Implementations
    impl<T> Any for T where
        T: 'static + ?Sized,     [src]
    impl<T> Borrow<T> for T where
        T: ?Sized,     [src]
    impl<T> BorrowMut<T> for T where
        T: ?Sized,     [src]
    impl<T> From<T> for T[src]
    impl<T, U> Into<U> for T where
        U: From<T>,     [src]
    impl<T> Spanned for T where
        T: Spanned + ?Sized,     [src]
    impl<T> ToOwned for T where
        T: Clone,     [src]
    type Owned = T
    The resulting type after obtaining ownership.
    
-
    impl<T> ToOwned for T where
        T: Clone,     [src]
    type Owned = T
    The resulting type after obtaining ownership.
    
+
    impl<T, U> TryFrom<U> for T where
        U: Into<T>,     [src]
    type Error = Infallible
    The type returned in the event of a conversion error.
    
-
    impl<T, U> TryInto<U> for T where
        U: TryFrom<T>,     [src]
    type Error = <U as TryFrom<T>>::Error
    The type returned in the event of a conversion error.
    
-
    
\ No newline at end of file
+

    impl<T, U> TryFrom<U> for T where
        U: Into<T>,     [src]

    type Error = Infallible

    The type returned in the event of a conversion error.

    +

    impl<T, U> TryInto<U> for T where
        U: TryFrom<T>,     [src]

    type Error = <U as TryFrom<T>>::Error

    The type returned in the event of a conversion error.

    +
    + \ No newline at end of file diff --git a/syn/token/struct.Eq.html b/syn/token/struct.Eq.html index 5c8eeba..4f99cee 100644 --- a/syn/token/struct.Eq.html +++ b/syn/token/struct.Eq.html @@ -1,40 +1,41 @@ -syn::token::Eq - Rust +syn::token::Eq - Rust -

    [−][src]Struct syn::token::Eq

    #[repr(C)]pub struct Eq {
+
    Struct syn::token::Eq[−][src]
    #[repr(C)]pub struct Eq {
     pub spans: [Span; 1],
 }
    =
    
-
    Don't try to remember the name of this type — use the
+
    Don’t try to remember the name of this type — use the
 Token! macro instead.
    
 
    
                        Fields
    spans: [Span; 1]
    Trait Implementations
    impl Clone for Eq[src]
    impl Copy for Eq[src]
    impl Debug for Eq[src]
    impl Default for Eq[src]
    impl Default for Eq[src]
    impl Deref for Eq[src]
    type Target = WithSpan
    The resulting type after dereferencing.
    
 
    impl DerefMut for Eq[src]
    impl Eq for Eq[src]
    impl Hash for Eq[src]
    impl Parse for Eq[src]
    impl PartialEq<Eq> for Eq[src]
    impl ToTokens for Eq[src]
    impl Token for Eq[src]
    Auto Trait Implementations
    impl RefUnwindSafe for Eq[src]
    impl !Send for Eq[src]
    impl !Sync for Eq[src]
    impl Unpin for Eq[src]
    impl UnwindSafe for Eq[src]
    Blanket Implementations
    impl<T> Any for T where
        T: 'static + ?Sized,     [src]
    impl<T> Borrow<T> for T where
        T: ?Sized,     [src]
    impl<T> BorrowMut<T> for T where
        T: ?Sized,     [src]
    impl<T> From<T> for T[src]
    impl<T, U> Into<U> for T where
        U: From<T>,     [src]
    impl Token for Eq[src]
    Auto Trait Implementations
    impl RefUnwindSafe for Eq
    impl !Send for Eq
    impl !Sync for Eq
    impl Unpin for Eq
    impl UnwindSafe for Eq
    Blanket Implementations
    impl<T> Any for T where
        T: 'static + ?Sized,     [src]
    impl<T> Borrow<T> for T where
        T: ?Sized,     [src]
    impl<T> BorrowMut<T> for T where
        T: ?Sized,     [src]
    impl<T> From<T> for T[src]
    impl<T, U> Into<U> for T where
        U: From<T>,     [src]
    impl<T> Spanned for T where
        T: Spanned + ?Sized,     [src]
    impl<T> ToOwned for T where
        T: Clone,     [src]
    type Owned = T
    The resulting type after obtaining ownership.
    
-
    impl<T> ToOwned for T where
        T: Clone,     [src]
    type Owned = T
    The resulting type after obtaining ownership.
    
+
    impl<T, U> TryFrom<U> for T where
        U: Into<T>,     [src]
    type Error = Infallible
    The type returned in the event of a conversion error.
    
-
    impl<T, U> TryInto<U> for T where
        U: TryFrom<T>,     [src]
    type Error = <U as TryFrom<T>>::Error
    The type returned in the event of a conversion error.
    
-
    
\ No newline at end of file
+

    impl<T, U> TryFrom<U> for T where
        U: Into<T>,     [src]

    type Error = Infallible

    The type returned in the event of a conversion error.

    +

    impl<T, U> TryInto<U> for T where
        U: TryFrom<T>,     [src]

    type Error = <U as TryFrom<T>>::Error

    The type returned in the event of a conversion error.

    +
    + \ No newline at end of file diff --git a/syn/token/struct.EqEq.html b/syn/token/struct.EqEq.html index dec4735..c105094 100644 --- a/syn/token/struct.EqEq.html +++ b/syn/token/struct.EqEq.html @@ -1,37 +1,38 @@ -syn::token::EqEq - Rust +syn::token::EqEq - Rust -

    [−][src]Struct syn::token::EqEq

    #[repr(C)]pub struct EqEq {
+
    Struct syn::token::EqEq[−][src]
    #[repr(C)]pub struct EqEq {
     pub spans: [Span; 2],
 }
    ==
    
-
    Don't try to remember the name of this type — use the
+
    Don’t try to remember the name of this type — use the
 Token! macro instead.
    
 
    
                        Fields
    spans: [Span; 2]
    Trait Implementations
    impl Clone for EqEq[src]
    impl Copy for EqEq[src]
    impl Debug for EqEq[src]
    impl Default for EqEq[src]
    impl Default for EqEq[src]
    impl Eq for EqEq[src]
    impl Hash for EqEq[src]
    impl Parse for EqEq[src]
    impl PartialEq<EqEq> for EqEq[src]
    impl ToTokens for EqEq[src]
    impl Token for EqEq[src]
    Auto Trait Implementations
    Blanket Implementations
    impl<T> Any for T where
        T: 'static + ?Sized,     [src]
    impl<T> Borrow<T> for T where
        T: ?Sized,     [src]
    impl<T> BorrowMut<T> for T where
        T: ?Sized,     [src]
    impl<T> From<T> for T[src]
    impl<T, U> Into<U> for T where
        U: From<T>,     [src]
    impl Token for EqEq[src]
    Auto Trait Implementations
    impl RefUnwindSafe for EqEq
    impl !Send for EqEq
    impl !Sync for EqEq
    impl Unpin for EqEq
    impl UnwindSafe for EqEq
    Blanket Implementations
    impl<T> Any for T where
        T: 'static + ?Sized,     [src]
    impl<T> Borrow<T> for T where
        T: ?Sized,     [src]
    impl<T> BorrowMut<T> for T where
        T: ?Sized,     [src]
    impl<T> From<T> for T[src]
    impl<T, U> Into<U> for T where
        U: From<T>,     [src]
    impl<T> Spanned for T where
        T: Spanned + ?Sized,     [src]
    impl<T> ToOwned for T where
        T: Clone,     [src]
    type Owned = T
    The resulting type after obtaining ownership.
    
-
    impl<T> ToOwned for T where
        T: Clone,     [src]
    type Owned = T
    The resulting type after obtaining ownership.
    
+
    impl<T, U> TryFrom<U> for T where
        U: Into<T>,     [src]
    type Error = Infallible
    The type returned in the event of a conversion error.
    
-
    impl<T, U> TryInto<U> for T where
        U: TryFrom<T>,     [src]
    type Error = <U as TryFrom<T>>::Error
    The type returned in the event of a conversion error.
    
-
    
\ No newline at end of file
+

    impl<T, U> TryFrom<U> for T where
        U: Into<T>,     [src]

    type Error = Infallible

    The type returned in the event of a conversion error.

    +

    impl<T, U> TryInto<U> for T where
        U: TryFrom<T>,     [src]

    type Error = <U as TryFrom<T>>::Error

    The type returned in the event of a conversion error.

    +
    + \ No newline at end of file diff --git a/syn/token/struct.Extern.html b/syn/token/struct.Extern.html index de04abe..b90bce9 100644 --- a/syn/token/struct.Extern.html +++ b/syn/token/struct.Extern.html @@ -1,38 +1,39 @@ -syn::token::Extern - Rust +syn::token::Extern - Rust -

    [−][src]Struct syn::token::Extern

    pub struct Extern {
+
    Struct syn::token::Extern[−][src]
    pub struct Extern {
     pub span: Span,
 }
    extern
    
-
    Don't try to remember the name of this type — use the
+
    Don’t try to remember the name of this type — use the
 Token! macro instead.
    
 
    
                        Fields
    span: Span
    Trait Implementations
    impl Clone for Extern[src]
    impl Copy for Extern[src]
    impl Debug for Extern[src]
    impl Default for Extern[src]
    impl Default for Extern[src]
    impl Eq for Extern[src]
    impl From<Extern> for Ident[src]
    impl Hash for Extern[src]
    impl Parse for Extern[src]
    impl PartialEq<Extern> for Extern[src]
    impl ToTokens for Extern[src]
    impl Token for Extern[src]
    Auto Trait Implementations
    Blanket Implementations
    impl<T> Any for T where
        T: 'static + ?Sized,     [src]
    impl<T> Borrow<T> for T where
        T: ?Sized,     [src]
    impl<T> BorrowMut<T> for T where
        T: ?Sized,     [src]
    impl<T> From<T> for T[src]
    impl<T, U> Into<U> for T where
        U: From<T>,     [src]
    impl Token for Extern[src]
    Auto Trait Implementations
    impl RefUnwindSafe for Extern
    impl !Send for Extern
    impl !Sync for Extern
    impl Unpin for Extern
    impl UnwindSafe for Extern
    Blanket Implementations
    impl<T> Any for T where
        T: 'static + ?Sized,     [src]
    impl<T> Borrow<T> for T where
        T: ?Sized,     [src]
    impl<T> BorrowMut<T> for T where
        T: ?Sized,     [src]
    impl<T> From<T> for T[src]
    impl<T, U> Into<U> for T where
        U: From<T>,     [src]
    impl<T> Spanned for T where
        T: Spanned + ?Sized,     [src]
    impl<T> ToOwned for T where
        T: Clone,     [src]
    type Owned = T
    The resulting type after obtaining ownership.
    
-
    impl<T> ToOwned for T where
        T: Clone,     [src]
    type Owned = T
    The resulting type after obtaining ownership.
    
+
    impl<T, U> TryFrom<U> for T where
        U: Into<T>,     [src]
    type Error = Infallible
    The type returned in the event of a conversion error.
    
-
    impl<T, U> TryInto<U> for T where
        U: TryFrom<T>,     [src]
    type Error = <U as TryFrom<T>>::Error
    The type returned in the event of a conversion error.
    
-
    
\ No newline at end of file
+

    impl<T, U> TryFrom<U> for T where
        U: Into<T>,     [src]

    type Error = Infallible

    The type returned in the event of a conversion error.

    +

    impl<T, U> TryInto<U> for T where
        U: TryFrom<T>,     [src]

    type Error = <U as TryFrom<T>>::Error

    The type returned in the event of a conversion error.

    +
    + \ No newline at end of file diff --git a/syn/token/struct.FatArrow.html b/syn/token/struct.FatArrow.html index e77648f..986cb5e 100644 --- a/syn/token/struct.FatArrow.html +++ b/syn/token/struct.FatArrow.html @@ -1,37 +1,38 @@ -syn::token::FatArrow - Rust +syn::token::FatArrow - Rust -

    [−][src]Struct syn::token::FatArrow

    #[repr(C)]pub struct FatArrow {
+
    Struct syn::token::FatArrow[−][src]
    #[repr(C)]pub struct FatArrow {
     pub spans: [Span; 2],
 }
    =>
    
-
    Don't try to remember the name of this type — use the
+
    Don’t try to remember the name of this type — use the
 Token! macro instead.
    
 
    
                        Fields
    spans: [Span; 2]
    Trait Implementations
    impl Clone for FatArrow[src]
    impl Copy for FatArrow[src]
    impl Debug for FatArrow[src]
    impl Default for FatArrow[src]
    impl Default for FatArrow[src]
    impl Eq for FatArrow[src]
    impl Hash for FatArrow[src]
    impl Parse for FatArrow[src]
    impl PartialEq<FatArrow> for FatArrow[src]
    impl ToTokens for FatArrow[src]
    impl Token for FatArrow[src]
    Auto Trait Implementations
    Blanket Implementations
    impl<T> Any for T where
        T: 'static + ?Sized,     [src]
    impl<T> Borrow<T> for T where
        T: ?Sized,     [src]
    impl<T> BorrowMut<T> for T where
        T: ?Sized,     [src]
    impl<T> From<T> for T[src]
    impl<T, U> Into<U> for T where
        U: From<T>,     [src]
    impl Token for FatArrow[src]
    Auto Trait Implementations
    impl RefUnwindSafe for FatArrow
    impl !Send for FatArrow
    impl !Sync for FatArrow
    impl Unpin for FatArrow
    impl UnwindSafe for FatArrow
    Blanket Implementations
    impl<T> Any for T where
        T: 'static + ?Sized,     [src]
    impl<T> Borrow<T> for T where
        T: ?Sized,     [src]
    impl<T> BorrowMut<T> for T where
        T: ?Sized,     [src]
    impl<T> From<T> for T[src]
    impl<T, U> Into<U> for T where
        U: From<T>,     [src]
    impl<T> Spanned for T where
        T: Spanned + ?Sized,     [src]
    impl<T> ToOwned for T where
        T: Clone,     [src]
    type Owned = T
    The resulting type after obtaining ownership.
    
-
    impl<T> ToOwned for T where
        T: Clone,     [src]
    type Owned = T
    The resulting type after obtaining ownership.
    
+
    impl<T, U> TryFrom<U> for T where
        U: Into<T>,     [src]
    type Error = Infallible
    The type returned in the event of a conversion error.
    
-
    impl<T, U> TryInto<U> for T where
        U: TryFrom<T>,     [src]
    type Error = <U as TryFrom<T>>::Error
    The type returned in the event of a conversion error.
    
-
    
\ No newline at end of file
+

    impl<T, U> TryFrom<U> for T where
        U: Into<T>,     [src]

    type Error = Infallible

    The type returned in the event of a conversion error.

    +

    impl<T, U> TryInto<U> for T where
        U: TryFrom<T>,     [src]

    type Error = <U as TryFrom<T>>::Error

    The type returned in the event of a conversion error.

    +
    + \ No newline at end of file diff --git a/syn/token/struct.Final.html b/syn/token/struct.Final.html index d005921..5af7b53 100644 --- a/syn/token/struct.Final.html +++ b/syn/token/struct.Final.html @@ -1,37 +1,38 @@ -syn::token::Final - Rust +syn::token::Final - Rust -

    [−][src]Struct syn::token::Final

    pub struct Final {
+
    Struct syn::token::Final[−][src]
    pub struct Final {
     pub span: Span,
 }
    final
    
-
    Don't try to remember the name of this type — use the
+
    Don’t try to remember the name of this type — use the
 Token! macro instead.
    
 
    
                        Fields
    span: Span
    Trait Implementations
    impl Clone for Final[src]
    impl Copy for Final[src]
    impl Debug for Final[src]
    impl Default for Final[src]
    impl Default for Final[src]
    impl Eq for Final[src]
    impl Hash for Final[src]
    impl Parse for Final[src]
    impl PartialEq<Final> for Final[src]
    impl ToTokens for Final[src]
    impl Token for Final[src]
    Auto Trait Implementations
    Blanket Implementations
    impl<T> Any for T where
        T: 'static + ?Sized,     [src]
    impl<T> Borrow<T> for T where
        T: ?Sized,     [src]
    impl<T> BorrowMut<T> for T where
        T: ?Sized,     [src]
    impl<T> From<T> for T[src]
    impl<T, U> Into<U> for T where
        U: From<T>,     [src]
    impl Token for Final[src]
    Auto Trait Implementations
    impl RefUnwindSafe for Final
    impl !Send for Final
    impl !Sync for Final
    impl Unpin for Final
    impl UnwindSafe for Final
    Blanket Implementations
    impl<T> Any for T where
        T: 'static + ?Sized,     [src]
    impl<T> Borrow<T> for T where
        T: ?Sized,     [src]
    impl<T> BorrowMut<T> for T where
        T: ?Sized,     [src]
    impl<T> From<T> for T[src]
    impl<T, U> Into<U> for T where
        U: From<T>,     [src]
    impl<T> Spanned for T where
        T: Spanned + ?Sized,     [src]
    impl<T> ToOwned for T where
        T: Clone,     [src]
    type Owned = T
    The resulting type after obtaining ownership.
    
-
    impl<T> ToOwned for T where
        T: Clone,     [src]
    type Owned = T
    The resulting type after obtaining ownership.
    
+
    impl<T, U> TryFrom<U> for T where
        U: Into<T>,     [src]
    type Error = Infallible
    The type returned in the event of a conversion error.
    
-
    impl<T, U> TryInto<U> for T where
        U: TryFrom<T>,     [src]
    type Error = <U as TryFrom<T>>::Error
    The type returned in the event of a conversion error.
    
-
    
\ No newline at end of file
+

    impl<T, U> TryFrom<U> for T where
        U: Into<T>,     [src]

    type Error = Infallible

    The type returned in the event of a conversion error.

    +

    impl<T, U> TryInto<U> for T where
        U: TryFrom<T>,     [src]

    type Error = <U as TryFrom<T>>::Error

    The type returned in the event of a conversion error.

    +
    + \ No newline at end of file diff --git a/syn/token/struct.Fn.html b/syn/token/struct.Fn.html index 4b71ca8..cd79be8 100644 --- a/syn/token/struct.Fn.html +++ b/syn/token/struct.Fn.html @@ -1,37 +1,38 @@ -syn::token::Fn - Rust +syn::token::Fn - Rust -

    [−][src]Struct syn::token::Fn

    pub struct Fn {
+
    Struct syn::token::Fn[−][src]
    pub struct Fn {
     pub span: Span,
 }
    fn
    
-
    Don't try to remember the name of this type — use the
+
    Don’t try to remember the name of this type — use the
 Token! macro instead.
    
 
    
                        Fields
    span: Span
    Trait Implementations
    impl Clone for Fn[src]
    impl Copy for Fn[src]
    impl Debug for Fn[src]
    impl Default for Fn[src]
    impl Default for Fn[src]
    impl Eq for Fn[src]
    impl Hash for Fn[src]
    impl Parse for Fn[src]
    impl PartialEq<Fn> for Fn[src]
    impl ToTokens for Fn[src]
    impl Token for Fn[src]
    Auto Trait Implementations
    impl RefUnwindSafe for Fn[src]
    impl !Send for Fn[src]
    impl !Sync for Fn[src]
    impl Unpin for Fn[src]
    impl UnwindSafe for Fn[src]
    Blanket Implementations
    impl<T> Any for T where
        T: 'static + ?Sized,     [src]
    impl<T> Borrow<T> for T where
        T: ?Sized,     [src]
    impl<T> BorrowMut<T> for T where
        T: ?Sized,     [src]
    impl<T> From<T> for T[src]
    impl<T, U> Into<U> for T where
        U: From<T>,     [src]
    impl Token for Fn[src]
    Auto Trait Implementations
    impl RefUnwindSafe for Fn
    impl !Send for Fn
    impl !Sync for Fn
    impl Unpin for Fn
    impl UnwindSafe for Fn
    Blanket Implementations
    impl<T> Any for T where
        T: 'static + ?Sized,     [src]
    impl<T> Borrow<T> for T where
        T: ?Sized,     [src]
    impl<T> BorrowMut<T> for T where
        T: ?Sized,     [src]
    impl<T> From<T> for T[src]
    impl<T, U> Into<U> for T where
        U: From<T>,     [src]
    impl<T> Spanned for T where
        T: Spanned + ?Sized,     [src]
    impl<T> ToOwned for T where
        T: Clone,     [src]
    type Owned = T
    The resulting type after obtaining ownership.
    
-
    impl<T> ToOwned for T where
        T: Clone,     [src]
    type Owned = T
    The resulting type after obtaining ownership.
    
+
    impl<T, U> TryFrom<U> for T where
        U: Into<T>,     [src]
    type Error = Infallible
    The type returned in the event of a conversion error.
    
-
    impl<T, U> TryInto<U> for T where
        U: TryFrom<T>,     [src]
    type Error = <U as TryFrom<T>>::Error
    The type returned in the event of a conversion error.
    
-
    
\ No newline at end of file
+

    impl<T, U> TryFrom<U> for T where
        U: Into<T>,     [src]

    type Error = Infallible

    The type returned in the event of a conversion error.

    +

    impl<T, U> TryInto<U> for T where
        U: TryFrom<T>,     [src]

    type Error = <U as TryFrom<T>>::Error

    The type returned in the event of a conversion error.

    +
    + \ No newline at end of file diff --git a/syn/token/struct.For.html b/syn/token/struct.For.html index 9e621e7..f7ef1f2 100644 --- a/syn/token/struct.For.html +++ b/syn/token/struct.For.html @@ -1,37 +1,38 @@ -syn::token::For - Rust +syn::token::For - Rust -

    [−][src]Struct syn::token::For

    pub struct For {
+
    Struct syn::token::For[−][src]
    pub struct For {
     pub span: Span,
 }
    for
    
-
    Don't try to remember the name of this type — use the
+
    Don’t try to remember the name of this type — use the
 Token! macro instead.
    
 
    
                        Fields
    span: Span
    Trait Implementations
    impl Clone for For[src]
    impl Copy for For[src]
    impl Debug for For[src]
    impl Default for For[src]
    impl Default for For[src]
    impl Eq for For[src]
    impl Hash for For[src]
    impl Parse for For[src]
    impl PartialEq<For> for For[src]
    impl ToTokens for For[src]
    impl Token for For[src]
    Auto Trait Implementations
    impl RefUnwindSafe for For[src]
    impl !Send for For[src]
    impl !Sync for For[src]
    impl Unpin for For[src]
    impl UnwindSafe for For[src]
    Blanket Implementations
    impl<T> Any for T where
        T: 'static + ?Sized,     [src]
    impl<T> Borrow<T> for T where
        T: ?Sized,     [src]
    impl<T> BorrowMut<T> for T where
        T: ?Sized,     [src]
    impl<T> From<T> for T[src]
    impl<T, U> Into<U> for T where
        U: From<T>,     [src]
    impl Token for For[src]
    Auto Trait Implementations
    impl RefUnwindSafe for For
    impl !Send for For
    impl !Sync for For
    impl Unpin for For
    impl UnwindSafe for For
    Blanket Implementations
    impl<T> Any for T where
        T: 'static + ?Sized,     [src]
    impl<T> Borrow<T> for T where
        T: ?Sized,     [src]
    impl<T> BorrowMut<T> for T where
        T: ?Sized,     [src]
    impl<T> From<T> for T[src]
    impl<T, U> Into<U> for T where
        U: From<T>,     [src]
    impl<T> Spanned for T where
        T: Spanned + ?Sized,     [src]
    impl<T> ToOwned for T where
        T: Clone,     [src]
    type Owned = T
    The resulting type after obtaining ownership.
    
-
    impl<T> ToOwned for T where
        T: Clone,     [src]
    type Owned = T
    The resulting type after obtaining ownership.
    
+
    impl<T, U> TryFrom<U> for T where
        U: Into<T>,     [src]
    type Error = Infallible
    The type returned in the event of a conversion error.
    
-
    impl<T, U> TryInto<U> for T where
        U: TryFrom<T>,     [src]
    type Error = <U as TryFrom<T>>::Error
    The type returned in the event of a conversion error.
    
-
    
\ No newline at end of file
+

    impl<T, U> TryFrom<U> for T where
        U: Into<T>,     [src]

    type Error = Infallible

    The type returned in the event of a conversion error.

    +

    impl<T, U> TryInto<U> for T where
        U: TryFrom<T>,     [src]

    type Error = <U as TryFrom<T>>::Error

    The type returned in the event of a conversion error.

    +
    + \ No newline at end of file diff --git a/syn/token/struct.Ge.html b/syn/token/struct.Ge.html index 3be5cf5..6b883cf 100644 --- a/syn/token/struct.Ge.html +++ b/syn/token/struct.Ge.html @@ -1,37 +1,38 @@ -syn::token::Ge - Rust +syn::token::Ge - Rust -

    [−][src]Struct syn::token::Ge

    #[repr(C)]pub struct Ge {
+
    Struct syn::token::Ge[−][src]
    #[repr(C)]pub struct Ge {
     pub spans: [Span; 2],
 }
    >=
    
-
    Don't try to remember the name of this type — use the
+
    Don’t try to remember the name of this type — use the
 Token! macro instead.
    
 
    
                        Fields
    spans: [Span; 2]
    Trait Implementations
    impl Clone for Ge[src]
    impl Copy for Ge[src]
    impl Debug for Ge[src]
    impl Default for Ge[src]
    impl Default for Ge[src]
    impl Eq for Ge[src]
    impl Hash for Ge[src]
    impl Parse for Ge[src]
    impl PartialEq<Ge> for Ge[src]
    impl ToTokens for Ge[src]
    impl Token for Ge[src]
    Auto Trait Implementations
    impl RefUnwindSafe for Ge[src]
    impl !Send for Ge[src]
    impl !Sync for Ge[src]
    impl Unpin for Ge[src]
    impl UnwindSafe for Ge[src]
    Blanket Implementations
    impl<T> Any for T where
        T: 'static + ?Sized,     [src]
    impl<T> Borrow<T> for T where
        T: ?Sized,     [src]
    impl<T> BorrowMut<T> for T where
        T: ?Sized,     [src]
    impl<T> From<T> for T[src]
    impl<T, U> Into<U> for T where
        U: From<T>,     [src]
    impl Token for Ge[src]
    Auto Trait Implementations
    impl RefUnwindSafe for Ge
    impl !Send for Ge
    impl !Sync for Ge
    impl Unpin for Ge
    impl UnwindSafe for Ge
    Blanket Implementations
    impl<T> Any for T where
        T: 'static + ?Sized,     [src]
    impl<T> Borrow<T> for T where
        T: ?Sized,     [src]
    impl<T> BorrowMut<T> for T where
        T: ?Sized,     [src]
    impl<T> From<T> for T[src]
    impl<T, U> Into<U> for T where
        U: From<T>,     [src]
    impl<T> Spanned for T where
        T: Spanned + ?Sized,     [src]
    impl<T> ToOwned for T where
        T: Clone,     [src]
    type Owned = T
    The resulting type after obtaining ownership.
    
-
    impl<T> ToOwned for T where
        T: Clone,     [src]
    type Owned = T
    The resulting type after obtaining ownership.
    
+
    impl<T, U> TryFrom<U> for T where
        U: Into<T>,     [src]
    type Error = Infallible
    The type returned in the event of a conversion error.
    
-
    impl<T, U> TryInto<U> for T where
        U: TryFrom<T>,     [src]
    type Error = <U as TryFrom<T>>::Error
    The type returned in the event of a conversion error.
    
-
    
\ No newline at end of file
+

    impl<T, U> TryFrom<U> for T where
        U: Into<T>,     [src]

    type Error = Infallible

    The type returned in the event of a conversion error.

    +

    impl<T, U> TryInto<U> for T where
        U: TryFrom<T>,     [src]

    type Error = <U as TryFrom<T>>::Error

    The type returned in the event of a conversion error.

    +
    + \ No newline at end of file diff --git a/syn/token/struct.Group.html b/syn/token/struct.Group.html index 73a7d0e..0ecdcee 100644 --- a/syn/token/struct.Group.html +++ b/syn/token/struct.Group.html @@ -1,30 +1,31 @@ -syn::token::Group - Rust +syn::token::Group - Rust -

    [−][src]Struct syn::token::Group

    pub struct Group {
+
    Struct syn::token::Group[−][src]
    pub struct Group {
     pub span: Span,
 }
    None-delimited group
    
 
    
                        Fields
    span: Span
    Implementations
    impl Group[src]
    pub fn surround<F>(&self, tokens: &mut TokenStream, f: F) where
        F: FnOnce(&mut TokenStream),     [src]
    Trait Implementations
    impl Clone for Group[src]
    impl Copy for Group[src]
    impl Debug for Group[src]
    impl Default for Group[src]
    impl Default for Group[src]
    impl Eq for Group[src]
    impl Hash for Group[src]
    impl PartialEq<Group> for Group[src]
    impl Token for Group[src]
    Auto Trait Implementations
    Blanket Implementations
    impl<T> Any for T where
        T: 'static + ?Sized,     [src]
    impl<T> Borrow<T> for T where
        T: ?Sized,     [src]
    impl<T> BorrowMut<T> for T where
        T: ?Sized,     [src]
    impl<T> From<T> for T[src]
    impl<T, U> Into<U> for T where
        U: From<T>,     [src]
    impl<T> ToOwned for T where
        T: Clone,     [src]
    type Owned = T
    The resulting type after obtaining ownership.
    
-
    impl Token for Group[src]
    Auto Trait Implementations
    impl RefUnwindSafe for Group
    impl !Send for Group
    impl !Sync for Group
    impl Unpin for Group
    impl UnwindSafe for Group
    Blanket Implementations
    impl<T> Any for T where
        T: 'static + ?Sized,     [src]
    impl<T> Borrow<T> for T where
        T: ?Sized,     [src]
    impl<T> BorrowMut<T> for T where
        T: ?Sized,     [src]
    impl<T> From<T> for T[src]
    impl<T, U> Into<U> for T where
        U: From<T>,     [src]
    impl<T> ToOwned for T where
        T: Clone,     [src]
    type Owned = T
    The resulting type after obtaining ownership.
    
+
    impl<T, U> TryFrom<U> for T where
        U: Into<T>,     [src]
    type Error = Infallible
    The type returned in the event of a conversion error.
    
-
    impl<T, U> TryInto<U> for T where
        U: TryFrom<T>,     [src]
    type Error = <U as TryFrom<T>>::Error
    The type returned in the event of a conversion error.
    
-
    
\ No newline at end of file
+

    impl<T, U> TryFrom<U> for T where
        U: Into<T>,     [src]

    type Error = Infallible

    The type returned in the event of a conversion error.

    +

    impl<T, U> TryInto<U> for T where
        U: TryFrom<T>,     [src]

    type Error = <U as TryFrom<T>>::Error

    The type returned in the event of a conversion error.

    +
    + \ No newline at end of file diff --git a/syn/token/struct.Gt.html b/syn/token/struct.Gt.html index 50a3606..12fea04 100644 --- a/syn/token/struct.Gt.html +++ b/syn/token/struct.Gt.html @@ -1,40 +1,41 @@ -syn::token::Gt - Rust +syn::token::Gt - Rust -

    [−][src]Struct syn::token::Gt

    #[repr(C)]pub struct Gt {
+
    Struct syn::token::Gt[−][src]
    #[repr(C)]pub struct Gt {
     pub spans: [Span; 1],
 }
    >
    
-
    Don't try to remember the name of this type — use the
+
    Don’t try to remember the name of this type — use the
 Token! macro instead.
    
 
    
                        Fields
    spans: [Span; 1]
    Trait Implementations
    impl Clone for Gt[src]
    impl Copy for Gt[src]
    impl Debug for Gt[src]
    impl Default for Gt[src]
    impl Default for Gt[src]
    impl Deref for Gt[src]
    type Target = WithSpan
    The resulting type after dereferencing.
    
 
    impl DerefMut for Gt[src]
    impl Eq for Gt[src]
    impl Hash for Gt[src]
    impl Parse for Gt[src]
    impl PartialEq<Gt> for Gt[src]
    impl ToTokens for Gt[src]
    impl Token for Gt[src]
    Auto Trait Implementations
    impl RefUnwindSafe for Gt[src]
    impl !Send for Gt[src]
    impl !Sync for Gt[src]
    impl Unpin for Gt[src]
    impl UnwindSafe for Gt[src]
    Blanket Implementations
    impl<T> Any for T where
        T: 'static + ?Sized,     [src]
    impl<T> Borrow<T> for T where
        T: ?Sized,     [src]
    impl<T> BorrowMut<T> for T where
        T: ?Sized,     [src]
    impl<T> From<T> for T[src]
    impl<T, U> Into<U> for T where
        U: From<T>,     [src]
    impl Token for Gt[src]
    Auto Trait Implementations
    impl RefUnwindSafe for Gt
    impl !Send for Gt
    impl !Sync for Gt
    impl Unpin for Gt
    impl UnwindSafe for Gt
    Blanket Implementations
    impl<T> Any for T where
        T: 'static + ?Sized,     [src]
    impl<T> Borrow<T> for T where
        T: ?Sized,     [src]
    impl<T> BorrowMut<T> for T where
        T: ?Sized,     [src]
    impl<T> From<T> for T[src]
    impl<T, U> Into<U> for T where
        U: From<T>,     [src]
    impl<T> Spanned for T where
        T: Spanned + ?Sized,     [src]
    impl<T> ToOwned for T where
        T: Clone,     [src]
    type Owned = T
    The resulting type after obtaining ownership.
    
-
    impl<T> ToOwned for T where
        T: Clone,     [src]
    type Owned = T
    The resulting type after obtaining ownership.
    
+
    impl<T, U> TryFrom<U> for T where
        U: Into<T>,     [src]
    type Error = Infallible
    The type returned in the event of a conversion error.
    
-
    impl<T, U> TryInto<U> for T where
        U: TryFrom<T>,     [src]
    type Error = <U as TryFrom<T>>::Error
    The type returned in the event of a conversion error.
    
-
    
\ No newline at end of file
+

    impl<T, U> TryFrom<U> for T where
        U: Into<T>,     [src]

    type Error = Infallible

    The type returned in the event of a conversion error.

    +

    impl<T, U> TryInto<U> for T where
        U: TryFrom<T>,     [src]

    type Error = <U as TryFrom<T>>::Error

    The type returned in the event of a conversion error.

    +
    + \ No newline at end of file diff --git a/syn/token/struct.If.html b/syn/token/struct.If.html index 7f21624..a7b04c6 100644 --- a/syn/token/struct.If.html +++ b/syn/token/struct.If.html @@ -1,37 +1,38 @@ -syn::token::If - Rust +syn::token::If - Rust -

    [−][src]Struct syn::token::If

    pub struct If {
+
    Struct syn::token::If[−][src]
    pub struct If {
     pub span: Span,
 }
    if
    
-
    Don't try to remember the name of this type — use the
+
    Don’t try to remember the name of this type — use the
 Token! macro instead.
    
 
    
                        Fields
    span: Span
    Trait Implementations
    impl Clone for If[src]
    impl Copy for If[src]
    impl Debug for If[src]
    impl Default for If[src]
    impl Default for If[src]
    impl Eq for If[src]
    impl Hash for If[src]
    impl Parse for If[src]
    impl PartialEq<If> for If[src]
    impl ToTokens for If[src]
    impl Token for If[src]
    Auto Trait Implementations
    impl RefUnwindSafe for If[src]
    impl !Send for If[src]
    impl !Sync for If[src]
    impl Unpin for If[src]
    impl UnwindSafe for If[src]
    Blanket Implementations
    impl<T> Any for T where
        T: 'static + ?Sized,     [src]
    impl<T> Borrow<T> for T where
        T: ?Sized,     [src]
    impl<T> BorrowMut<T> for T where
        T: ?Sized,     [src]
    impl<T> From<T> for T[src]
    impl<T, U> Into<U> for T where
        U: From<T>,     [src]
    impl Token for If[src]
    Auto Trait Implementations
    impl RefUnwindSafe for If
    impl !Send for If
    impl !Sync for If
    impl Unpin for If
    impl UnwindSafe for If
    Blanket Implementations
    impl<T> Any for T where
        T: 'static + ?Sized,     [src]
    impl<T> Borrow<T> for T where
        T: ?Sized,     [src]
    impl<T> BorrowMut<T> for T where
        T: ?Sized,     [src]
    impl<T> From<T> for T[src]
    impl<T, U> Into<U> for T where
        U: From<T>,     [src]
    impl<T> Spanned for T where
        T: Spanned + ?Sized,     [src]
    impl<T> ToOwned for T where
        T: Clone,     [src]
    type Owned = T
    The resulting type after obtaining ownership.
    
-
    impl<T> ToOwned for T where
        T: Clone,     [src]
    type Owned = T
    The resulting type after obtaining ownership.
    
+
    impl<T, U> TryFrom<U> for T where
        U: Into<T>,     [src]
    type Error = Infallible
    The type returned in the event of a conversion error.
    
-
    impl<T, U> TryInto<U> for T where
        U: TryFrom<T>,     [src]
    type Error = <U as TryFrom<T>>::Error
    The type returned in the event of a conversion error.
    
-
    
\ No newline at end of file
+

    impl<T, U> TryFrom<U> for T where
        U: Into<T>,     [src]

    type Error = Infallible

    The type returned in the event of a conversion error.

    +

    impl<T, U> TryInto<U> for T where
        U: TryFrom<T>,     [src]

    type Error = <U as TryFrom<T>>::Error

    The type returned in the event of a conversion error.

    +
    + \ No newline at end of file diff --git a/syn/token/struct.Impl.html b/syn/token/struct.Impl.html index 358fc2f..4e64098 100644 --- a/syn/token/struct.Impl.html +++ b/syn/token/struct.Impl.html @@ -1,37 +1,38 @@ -syn::token::Impl - Rust +syn::token::Impl - Rust -

    [−][src]Struct syn::token::Impl

    pub struct Impl {
+
    Struct syn::token::Impl[−][src]
    pub struct Impl {
     pub span: Span,
 }
    impl
    
-
    Don't try to remember the name of this type — use the
+
    Don’t try to remember the name of this type — use the
 Token! macro instead.
    
 
    
                        Fields
    span: Span
    Trait Implementations
    impl Clone for Impl[src]
    impl Copy for Impl[src]
    impl Debug for Impl[src]
    impl Default for Impl[src]
    impl Default for Impl[src]
    impl Eq for Impl[src]
    impl Hash for Impl[src]
    impl Parse for Impl[src]
    impl PartialEq<Impl> for Impl[src]
    impl ToTokens for Impl[src]
    impl Token for Impl[src]
    Auto Trait Implementations
    Blanket Implementations
    impl<T> Any for T where
        T: 'static + ?Sized,     [src]
    impl<T> Borrow<T> for T where
        T: ?Sized,     [src]
    impl<T> BorrowMut<T> for T where
        T: ?Sized,     [src]
    impl<T> From<T> for T[src]
    impl<T, U> Into<U> for T where
        U: From<T>,     [src]
    impl Token for Impl[src]
    Auto Trait Implementations
    impl RefUnwindSafe for Impl
    impl !Send for Impl
    impl !Sync for Impl
    impl Unpin for Impl
    impl UnwindSafe for Impl
    Blanket Implementations
    impl<T> Any for T where
        T: 'static + ?Sized,     [src]
    impl<T> Borrow<T> for T where
        T: ?Sized,     [src]
    impl<T> BorrowMut<T> for T where
        T: ?Sized,     [src]
    impl<T> From<T> for T[src]
    impl<T, U> Into<U> for T where
        U: From<T>,     [src]
    impl<T> Spanned for T where
        T: Spanned + ?Sized,     [src]
    impl<T> ToOwned for T where
        T: Clone,     [src]
    type Owned = T
    The resulting type after obtaining ownership.
    
-
    impl<T> ToOwned for T where
        T: Clone,     [src]
    type Owned = T
    The resulting type after obtaining ownership.
    
+
    impl<T, U> TryFrom<U> for T where
        U: Into<T>,     [src]
    type Error = Infallible
    The type returned in the event of a conversion error.
    
-
    impl<T, U> TryInto<U> for T where
        U: TryFrom<T>,     [src]
    type Error = <U as TryFrom<T>>::Error
    The type returned in the event of a conversion error.
    
-
    
\ No newline at end of file
+

    impl<T, U> TryFrom<U> for T where
        U: Into<T>,     [src]

    type Error = Infallible

    The type returned in the event of a conversion error.

    +

    impl<T, U> TryInto<U> for T where
        U: TryFrom<T>,     [src]

    type Error = <U as TryFrom<T>>::Error

    The type returned in the event of a conversion error.

    +
    + \ No newline at end of file diff --git a/syn/token/struct.In.html b/syn/token/struct.In.html index e3975aa..61ed8b3 100644 --- a/syn/token/struct.In.html +++ b/syn/token/struct.In.html @@ -1,37 +1,38 @@ -syn::token::In - Rust +syn::token::In - Rust -

    [−][src]Struct syn::token::In

    pub struct In {
+
    Struct syn::token::In[−][src]
    pub struct In {
     pub span: Span,
 }
    in
    
-
    Don't try to remember the name of this type — use the
+
    Don’t try to remember the name of this type — use the
 Token! macro instead.
    
 
    
                        Fields
    span: Span
    Trait Implementations
    impl Clone for In[src]
    impl Copy for In[src]
    impl Debug for In[src]
    impl Default for In[src]
    impl Default for In[src]
    impl Eq for In[src]
    impl Hash for In[src]
    impl Parse for In[src]
    impl PartialEq<In> for In[src]
    impl ToTokens for In[src]
    impl Token for In[src]
    Auto Trait Implementations
    impl RefUnwindSafe for In[src]
    impl !Send for In[src]
    impl !Sync for In[src]
    impl Unpin for In[src]
    impl UnwindSafe for In[src]
    Blanket Implementations
    impl<T> Any for T where
        T: 'static + ?Sized,     [src]
    impl<T> Borrow<T> for T where
        T: ?Sized,     [src]
    impl<T> BorrowMut<T> for T where
        T: ?Sized,     [src]
    impl<T> From<T> for T[src]
    impl<T, U> Into<U> for T where
        U: From<T>,     [src]
    impl Token for In[src]
    Auto Trait Implementations
    impl RefUnwindSafe for In
    impl !Send for In
    impl !Sync for In
    impl Unpin for In
    impl UnwindSafe for In
    Blanket Implementations
    impl<T> Any for T where
        T: 'static + ?Sized,     [src]
    impl<T> Borrow<T> for T where
        T: ?Sized,     [src]
    impl<T> BorrowMut<T> for T where
        T: ?Sized,     [src]
    impl<T> From<T> for T[src]
    impl<T, U> Into<U> for T where
        U: From<T>,     [src]
    impl<T> Spanned for T where
        T: Spanned + ?Sized,     [src]
    impl<T> ToOwned for T where
        T: Clone,     [src]
    type Owned = T
    The resulting type after obtaining ownership.
    
-
    impl<T> ToOwned for T where
        T: Clone,     [src]
    type Owned = T
    The resulting type after obtaining ownership.
    
+
    impl<T, U> TryFrom<U> for T where
        U: Into<T>,     [src]
    type Error = Infallible
    The type returned in the event of a conversion error.
    
-
    impl<T, U> TryInto<U> for T where
        U: TryFrom<T>,     [src]
    type Error = <U as TryFrom<T>>::Error
    The type returned in the event of a conversion error.
    
-
    
\ No newline at end of file
+

    impl<T, U> TryFrom<U> for T where
        U: Into<T>,     [src]

    type Error = Infallible

    The type returned in the event of a conversion error.

    +

    impl<T, U> TryInto<U> for T where
        U: TryFrom<T>,     [src]

    type Error = <U as TryFrom<T>>::Error

    The type returned in the event of a conversion error.

    +
    + \ No newline at end of file diff --git a/syn/token/struct.LArrow.html b/syn/token/struct.LArrow.html index 1847fcd..f68ee7a 100644 --- a/syn/token/struct.LArrow.html +++ b/syn/token/struct.LArrow.html @@ -1,37 +1,38 @@ -syn::token::LArrow - Rust +syn::token::LArrow - Rust -

    [−][src]Struct syn::token::LArrow

    #[repr(C)]pub struct LArrow {
+
    Struct syn::token::LArrow[−][src]
    #[repr(C)]pub struct LArrow {
     pub spans: [Span; 2],
 }
    <-
    
-
    Don't try to remember the name of this type — use the
+
    Don’t try to remember the name of this type — use the
 Token! macro instead.
    
 
    
                        Fields
    spans: [Span; 2]
    Trait Implementations
    impl Clone for LArrow[src]
    impl Copy for LArrow[src]
    impl Debug for LArrow[src]
    impl Default for LArrow[src]
    impl Default for LArrow[src]
    impl Eq for LArrow[src]
    impl Hash for LArrow[src]
    impl Parse for LArrow[src]
    impl PartialEq<LArrow> for LArrow[src]
    impl ToTokens for LArrow[src]
    impl Token for LArrow[src]
    Auto Trait Implementations
    Blanket Implementations
    impl<T> Any for T where
        T: 'static + ?Sized,     [src]
    impl<T> Borrow<T> for T where
        T: ?Sized,     [src]
    impl<T> BorrowMut<T> for T where
        T: ?Sized,     [src]
    impl<T> From<T> for T[src]
    impl<T, U> Into<U> for T where
        U: From<T>,     [src]
    impl Token for LArrow[src]
    Auto Trait Implementations
    impl RefUnwindSafe for LArrow
    impl !Send for LArrow
    impl !Sync for LArrow
    impl Unpin for LArrow
    impl UnwindSafe for LArrow
    Blanket Implementations
    impl<T> Any for T where
        T: 'static + ?Sized,     [src]
    impl<T> Borrow<T> for T where
        T: ?Sized,     [src]
    impl<T> BorrowMut<T> for T where
        T: ?Sized,     [src]
    impl<T> From<T> for T[src]
    impl<T, U> Into<U> for T where
        U: From<T>,     [src]
    impl<T> Spanned for T where
        T: Spanned + ?Sized,     [src]
    impl<T> ToOwned for T where
        T: Clone,     [src]
    type Owned = T
    The resulting type after obtaining ownership.
    
-
    impl<T> ToOwned for T where
        T: Clone,     [src]
    type Owned = T
    The resulting type after obtaining ownership.
    
+
    impl<T, U> TryFrom<U> for T where
        U: Into<T>,     [src]
    type Error = Infallible
    The type returned in the event of a conversion error.
    
-
    impl<T, U> TryInto<U> for T where
        U: TryFrom<T>,     [src]
    type Error = <U as TryFrom<T>>::Error
    The type returned in the event of a conversion error.
    
-
    
\ No newline at end of file
+

    impl<T, U> TryFrom<U> for T where
        U: Into<T>,     [src]

    type Error = Infallible

    The type returned in the event of a conversion error.

    +

    impl<T, U> TryInto<U> for T where
        U: TryFrom<T>,     [src]

    type Error = <U as TryFrom<T>>::Error

    The type returned in the event of a conversion error.

    +
    + \ No newline at end of file diff --git a/syn/token/struct.Le.html b/syn/token/struct.Le.html index 378da46..adcb664 100644 --- a/syn/token/struct.Le.html +++ b/syn/token/struct.Le.html @@ -1,37 +1,38 @@ -syn::token::Le - Rust +syn::token::Le - Rust -

    [−][src]Struct syn::token::Le

    #[repr(C)]pub struct Le {
+
    Struct syn::token::Le[−][src]
    #[repr(C)]pub struct Le {
     pub spans: [Span; 2],
 }
    <=
    
-
    Don't try to remember the name of this type — use the
+
    Don’t try to remember the name of this type — use the
 Token! macro instead.
    
 
    
                        Fields
    spans: [Span; 2]
    Trait Implementations
    impl Clone for Le[src]
    impl Copy for Le[src]
    impl Debug for Le[src]
    impl Default for Le[src]
    impl Default for Le[src]
    impl Eq for Le[src]
    impl Hash for Le[src]
    impl Parse for Le[src]
    impl PartialEq<Le> for Le[src]
    impl ToTokens for Le[src]
    impl Token for Le[src]
    Auto Trait Implementations
    impl RefUnwindSafe for Le[src]
    impl !Send for Le[src]
    impl !Sync for Le[src]
    impl Unpin for Le[src]
    impl UnwindSafe for Le[src]
    Blanket Implementations
    impl<T> Any for T where
        T: 'static + ?Sized,     [src]
    impl<T> Borrow<T> for T where
        T: ?Sized,     [src]
    impl<T> BorrowMut<T> for T where
        T: ?Sized,     [src]
    impl<T> From<T> for T[src]
    impl<T, U> Into<U> for T where
        U: From<T>,     [src]
    impl Token for Le[src]
    Auto Trait Implementations
    impl RefUnwindSafe for Le
    impl !Send for Le
    impl !Sync for Le
    impl Unpin for Le
    impl UnwindSafe for Le
    Blanket Implementations
    impl<T> Any for T where
        T: 'static + ?Sized,     [src]
    impl<T> Borrow<T> for T where
        T: ?Sized,     [src]
    impl<T> BorrowMut<T> for T where
        T: ?Sized,     [src]
    impl<T> From<T> for T[src]
    impl<T, U> Into<U> for T where
        U: From<T>,     [src]
    impl<T> Spanned for T where
        T: Spanned + ?Sized,     [src]
    impl<T> ToOwned for T where
        T: Clone,     [src]
    type Owned = T
    The resulting type after obtaining ownership.
    
-
    impl<T> ToOwned for T where
        T: Clone,     [src]
    type Owned = T
    The resulting type after obtaining ownership.
    
+
    impl<T, U> TryFrom<U> for T where
        U: Into<T>,     [src]
    type Error = Infallible
    The type returned in the event of a conversion error.
    
-
    impl<T, U> TryInto<U> for T where
        U: TryFrom<T>,     [src]
    type Error = <U as TryFrom<T>>::Error
    The type returned in the event of a conversion error.
    
-
    
\ No newline at end of file
+

    impl<T, U> TryFrom<U> for T where
        U: Into<T>,     [src]

    type Error = Infallible

    The type returned in the event of a conversion error.

    +

    impl<T, U> TryInto<U> for T where
        U: TryFrom<T>,     [src]

    type Error = <U as TryFrom<T>>::Error

    The type returned in the event of a conversion error.

    +
    + \ No newline at end of file diff --git a/syn/token/struct.Let.html b/syn/token/struct.Let.html index ecb8b13..d49a11a 100644 --- a/syn/token/struct.Let.html +++ b/syn/token/struct.Let.html @@ -1,37 +1,38 @@ -syn::token::Let - Rust +syn::token::Let - Rust -

    [−][src]Struct syn::token::Let

    pub struct Let {
+
    Struct syn::token::Let[−][src]
    pub struct Let {
     pub span: Span,
 }
    let
    
-
    Don't try to remember the name of this type — use the
+
    Don’t try to remember the name of this type — use the
 Token! macro instead.
    
 
    
                        Fields
    span: Span
    Trait Implementations
    impl Clone for Let[src]
    impl Copy for Let[src]
    impl Debug for Let[src]
    impl Default for Let[src]
    impl Default for Let[src]
    impl Eq for Let[src]
    impl Hash for Let[src]
    impl Parse for Let[src]
    impl PartialEq<Let> for Let[src]
    impl ToTokens for Let[src]
    impl Token for Let[src]
    Auto Trait Implementations
    impl RefUnwindSafe for Let[src]
    impl !Send for Let[src]
    impl !Sync for Let[src]
    impl Unpin for Let[src]
    impl UnwindSafe for Let[src]
    Blanket Implementations
    impl<T> Any for T where
        T: 'static + ?Sized,     [src]
    impl<T> Borrow<T> for T where
        T: ?Sized,     [src]
    impl<T> BorrowMut<T> for T where
        T: ?Sized,     [src]
    impl<T> From<T> for T[src]
    impl<T, U> Into<U> for T where
        U: From<T>,     [src]
    impl Token for Let[src]
    Auto Trait Implementations
    impl RefUnwindSafe for Let
    impl !Send for Let
    impl !Sync for Let
    impl Unpin for Let
    impl UnwindSafe for Let
    Blanket Implementations
    impl<T> Any for T where
        T: 'static + ?Sized,     [src]
    impl<T> Borrow<T> for T where
        T: ?Sized,     [src]
    impl<T> BorrowMut<T> for T where
        T: ?Sized,     [src]
    impl<T> From<T> for T[src]
    impl<T, U> Into<U> for T where
        U: From<T>,     [src]
    impl<T> Spanned for T where
        T: Spanned + ?Sized,     [src]
    impl<T> ToOwned for T where
        T: Clone,     [src]
    type Owned = T
    The resulting type after obtaining ownership.
    
-
    impl<T> ToOwned for T where
        T: Clone,     [src]
    type Owned = T
    The resulting type after obtaining ownership.
    
+
    impl<T, U> TryFrom<U> for T where
        U: Into<T>,     [src]
    type Error = Infallible
    The type returned in the event of a conversion error.
    
-
    impl<T, U> TryInto<U> for T where
        U: TryFrom<T>,     [src]
    type Error = <U as TryFrom<T>>::Error
    The type returned in the event of a conversion error.
    
-
    
\ No newline at end of file
+

    impl<T, U> TryFrom<U> for T where
        U: Into<T>,     [src]

    type Error = Infallible

    The type returned in the event of a conversion error.

    +

    impl<T, U> TryInto<U> for T where
        U: TryFrom<T>,     [src]

    type Error = <U as TryFrom<T>>::Error

    The type returned in the event of a conversion error.

    +
    + \ No newline at end of file diff --git a/syn/token/struct.Loop.html b/syn/token/struct.Loop.html index 817602d..106cf9c 100644 --- a/syn/token/struct.Loop.html +++ b/syn/token/struct.Loop.html @@ -1,37 +1,38 @@ -syn::token::Loop - Rust +syn::token::Loop - Rust -

    [−][src]Struct syn::token::Loop

    pub struct Loop {
+
    Struct syn::token::Loop[−][src]
    pub struct Loop {
     pub span: Span,
 }
    loop
    
-
    Don't try to remember the name of this type — use the
+
    Don’t try to remember the name of this type — use the
 Token! macro instead.
    
 
    
                        Fields
    span: Span
    Trait Implementations
    impl Clone for Loop[src]
    impl Copy for Loop[src]
    impl Debug for Loop[src]
    impl Default for Loop[src]
    impl Default for Loop[src]
    impl Eq for Loop[src]
    impl Hash for Loop[src]
    impl Parse for Loop[src]
    impl PartialEq<Loop> for Loop[src]
    impl ToTokens for Loop[src]
    impl Token for Loop[src]
    Auto Trait Implementations
    Blanket Implementations
    impl<T> Any for T where
        T: 'static + ?Sized,     [src]
    impl<T> Borrow<T> for T where
        T: ?Sized,     [src]
    impl<T> BorrowMut<T> for T where
        T: ?Sized,     [src]
    impl<T> From<T> for T[src]
    impl<T, U> Into<U> for T where
        U: From<T>,     [src]
    impl Token for Loop[src]
    Auto Trait Implementations
    impl RefUnwindSafe for Loop
    impl !Send for Loop
    impl !Sync for Loop
    impl Unpin for Loop
    impl UnwindSafe for Loop
    Blanket Implementations
    impl<T> Any for T where
        T: 'static + ?Sized,     [src]
    impl<T> Borrow<T> for T where
        T: ?Sized,     [src]
    impl<T> BorrowMut<T> for T where
        T: ?Sized,     [src]
    impl<T> From<T> for T[src]
    impl<T, U> Into<U> for T where
        U: From<T>,     [src]
    impl<T> Spanned for T where
        T: Spanned + ?Sized,     [src]
    impl<T> ToOwned for T where
        T: Clone,     [src]
    type Owned = T
    The resulting type after obtaining ownership.
    
-
    impl<T> ToOwned for T where
        T: Clone,     [src]
    type Owned = T
    The resulting type after obtaining ownership.
    
+
    impl<T, U> TryFrom<U> for T where
        U: Into<T>,     [src]
    type Error = Infallible
    The type returned in the event of a conversion error.
    
-
    impl<T, U> TryInto<U> for T where
        U: TryFrom<T>,     [src]
    type Error = <U as TryFrom<T>>::Error
    The type returned in the event of a conversion error.
    
-
    
\ No newline at end of file
+

    impl<T, U> TryFrom<U> for T where
        U: Into<T>,     [src]

    type Error = Infallible

    The type returned in the event of a conversion error.

    +

    impl<T, U> TryInto<U> for T where
        U: TryFrom<T>,     [src]

    type Error = <U as TryFrom<T>>::Error

    The type returned in the event of a conversion error.

    +
    + \ No newline at end of file diff --git a/syn/token/struct.Lt.html b/syn/token/struct.Lt.html index 7728e82..aac116a 100644 --- a/syn/token/struct.Lt.html +++ b/syn/token/struct.Lt.html @@ -1,40 +1,41 @@ -syn::token::Lt - Rust +syn::token::Lt - Rust -

    [−][src]Struct syn::token::Lt

    #[repr(C)]pub struct Lt {
+
    Struct syn::token::Lt[−][src]
    #[repr(C)]pub struct Lt {
     pub spans: [Span; 1],
 }
    <
    
-
    Don't try to remember the name of this type — use the
+
    Don’t try to remember the name of this type — use the
 Token! macro instead.
    
 
    
                        Fields
    spans: [Span; 1]
    Trait Implementations
    impl Clone for Lt[src]
    impl Copy for Lt[src]
    impl Debug for Lt[src]
    impl Default for Lt[src]
    impl Default for Lt[src]
    impl Deref for Lt[src]
    type Target = WithSpan
    The resulting type after dereferencing.
    
 
    impl DerefMut for Lt[src]
    impl Eq for Lt[src]
    impl Hash for Lt[src]
    impl Parse for Lt[src]
    impl PartialEq<Lt> for Lt[src]
    impl ToTokens for Lt[src]
    impl Token for Lt[src]
    Auto Trait Implementations
    impl RefUnwindSafe for Lt[src]
    impl !Send for Lt[src]
    impl !Sync for Lt[src]
    impl Unpin for Lt[src]
    impl UnwindSafe for Lt[src]
    Blanket Implementations
    impl<T> Any for T where
        T: 'static + ?Sized,     [src]
    impl<T> Borrow<T> for T where
        T: ?Sized,     [src]
    impl<T> BorrowMut<T> for T where
        T: ?Sized,     [src]
    impl<T> From<T> for T[src]
    impl<T, U> Into<U> for T where
        U: From<T>,     [src]
    impl Token for Lt[src]
    Auto Trait Implementations
    impl RefUnwindSafe for Lt
    impl !Send for Lt
    impl !Sync for Lt
    impl Unpin for Lt
    impl UnwindSafe for Lt
    Blanket Implementations
    impl<T> Any for T where
        T: 'static + ?Sized,     [src]
    impl<T> Borrow<T> for T where
        T: ?Sized,     [src]
    impl<T> BorrowMut<T> for T where
        T: ?Sized,     [src]
    impl<T> From<T> for T[src]
    impl<T, U> Into<U> for T where
        U: From<T>,     [src]
    impl<T> Spanned for T where
        T: Spanned + ?Sized,     [src]
    impl<T> ToOwned for T where
        T: Clone,     [src]
    type Owned = T
    The resulting type after obtaining ownership.
    
-
    impl<T> ToOwned for T where
        T: Clone,     [src]
    type Owned = T
    The resulting type after obtaining ownership.
    
+
    impl<T, U> TryFrom<U> for T where
        U: Into<T>,     [src]
    type Error = Infallible
    The type returned in the event of a conversion error.
    
-
    impl<T, U> TryInto<U> for T where
        U: TryFrom<T>,     [src]
    type Error = <U as TryFrom<T>>::Error
    The type returned in the event of a conversion error.
    
-
    
\ No newline at end of file
+

    impl<T, U> TryFrom<U> for T where
        U: Into<T>,     [src]

    type Error = Infallible

    The type returned in the event of a conversion error.

    +

    impl<T, U> TryInto<U> for T where
        U: TryFrom<T>,     [src]

    type Error = <U as TryFrom<T>>::Error

    The type returned in the event of a conversion error.

    +
    + \ No newline at end of file diff --git a/syn/token/struct.Macro.html b/syn/token/struct.Macro.html index cd3dc4c..b81d73c 100644 --- a/syn/token/struct.Macro.html +++ b/syn/token/struct.Macro.html @@ -1,37 +1,38 @@ -syn::token::Macro - Rust +syn::token::Macro - Rust -

    [−][src]Struct syn::token::Macro

    pub struct Macro {
+
    Struct syn::token::Macro[−][src]
    pub struct Macro {
     pub span: Span,
 }
    macro
    
-
    Don't try to remember the name of this type — use the
+
    Don’t try to remember the name of this type — use the
 Token! macro instead.
    
 
    
                        Fields
    span: Span
    Trait Implementations
    impl Clone for Macro[src]
    impl Copy for Macro[src]
    impl Debug for Macro[src]
    impl Default for Macro[src]
    impl Default for Macro[src]
    impl Eq for Macro[src]
    impl Hash for Macro[src]
    impl Parse for Macro[src]
    impl PartialEq<Macro> for Macro[src]
    impl ToTokens for Macro[src]
    impl Token for Macro[src]
    Auto Trait Implementations
    Blanket Implementations
    impl<T> Any for T where
        T: 'static + ?Sized,     [src]
    impl<T> Borrow<T> for T where
        T: ?Sized,     [src]
    impl<T> BorrowMut<T> for T where
        T: ?Sized,     [src]
    impl<T> From<T> for T[src]
    impl<T, U> Into<U> for T where
        U: From<T>,     [src]
    impl Token for Macro[src]
    Auto Trait Implementations
    impl RefUnwindSafe for Macro
    impl !Send for Macro
    impl !Sync for Macro
    impl Unpin for Macro
    impl UnwindSafe for Macro
    Blanket Implementations
    impl<T> Any for T where
        T: 'static + ?Sized,     [src]
    impl<T> Borrow<T> for T where
        T: ?Sized,     [src]
    impl<T> BorrowMut<T> for T where
        T: ?Sized,     [src]
    impl<T> From<T> for T[src]
    impl<T, U> Into<U> for T where
        U: From<T>,     [src]
    impl<T> Spanned for T where
        T: Spanned + ?Sized,     [src]
    impl<T> ToOwned for T where
        T: Clone,     [src]
    type Owned = T
    The resulting type after obtaining ownership.
    
-
    impl<T> ToOwned for T where
        T: Clone,     [src]
    type Owned = T
    The resulting type after obtaining ownership.
    
+
    impl<T, U> TryFrom<U> for T where
        U: Into<T>,     [src]
    type Error = Infallible
    The type returned in the event of a conversion error.
    
-
    impl<T, U> TryInto<U> for T where
        U: TryFrom<T>,     [src]
    type Error = <U as TryFrom<T>>::Error
    The type returned in the event of a conversion error.
    
-
    
\ No newline at end of file
+

    impl<T, U> TryFrom<U> for T where
        U: Into<T>,     [src]

    type Error = Infallible

    The type returned in the event of a conversion error.

    +

    impl<T, U> TryInto<U> for T where
        U: TryFrom<T>,     [src]

    type Error = <U as TryFrom<T>>::Error

    The type returned in the event of a conversion error.

    +
    + \ No newline at end of file diff --git a/syn/token/struct.Match.html b/syn/token/struct.Match.html index 4027f4a..75b3be2 100644 --- a/syn/token/struct.Match.html +++ b/syn/token/struct.Match.html @@ -1,37 +1,38 @@ -syn::token::Match - Rust +syn::token::Match - Rust -

    [−][src]Struct syn::token::Match

    pub struct Match {
+
    Struct syn::token::Match[−][src]
    pub struct Match {
     pub span: Span,
 }
    match
    
-
    Don't try to remember the name of this type — use the
+
    Don’t try to remember the name of this type — use the
 Token! macro instead.
    
 
    
                        Fields
    span: Span
    Trait Implementations
    impl Clone for Match[src]
    impl Copy for Match[src]
    impl Debug for Match[src]
    impl Default for Match[src]
    impl Default for Match[src]
    impl Eq for Match[src]
    impl Hash for Match[src]
    impl Parse for Match[src]
    impl PartialEq<Match> for Match[src]
    impl ToTokens for Match[src]
    impl Token for Match[src]
    Auto Trait Implementations
    Blanket Implementations
    impl<T> Any for T where
        T: 'static + ?Sized,     [src]
    impl<T> Borrow<T> for T where
        T: ?Sized,     [src]
    impl<T> BorrowMut<T> for T where
        T: ?Sized,     [src]
    impl<T> From<T> for T[src]
    impl<T, U> Into<U> for T where
        U: From<T>,     [src]
    impl Token for Match[src]
    Auto Trait Implementations
    impl RefUnwindSafe for Match
    impl !Send for Match
    impl !Sync for Match
    impl Unpin for Match
    impl UnwindSafe for Match
    Blanket Implementations
    impl<T> Any for T where
        T: 'static + ?Sized,     [src]
    impl<T> Borrow<T> for T where
        T: ?Sized,     [src]
    impl<T> BorrowMut<T> for T where
        T: ?Sized,     [src]
    impl<T> From<T> for T[src]
    impl<T, U> Into<U> for T where
        U: From<T>,     [src]
    impl<T> Spanned for T where
        T: Spanned + ?Sized,     [src]
    impl<T> ToOwned for T where
        T: Clone,     [src]
    type Owned = T
    The resulting type after obtaining ownership.
    
-
    impl<T> ToOwned for T where
        T: Clone,     [src]
    type Owned = T
    The resulting type after obtaining ownership.
    
+
    impl<T, U> TryFrom<U> for T where
        U: Into<T>,     [src]
    type Error = Infallible
    The type returned in the event of a conversion error.
    
-
    impl<T, U> TryInto<U> for T where
        U: TryFrom<T>,     [src]
    type Error = <U as TryFrom<T>>::Error
    The type returned in the event of a conversion error.
    
-
    
\ No newline at end of file
+

    impl<T, U> TryFrom<U> for T where
        U: Into<T>,     [src]

    type Error = Infallible

    The type returned in the event of a conversion error.

    +

    impl<T, U> TryInto<U> for T where
        U: TryFrom<T>,     [src]

    type Error = <U as TryFrom<T>>::Error

    The type returned in the event of a conversion error.

    +
    + \ No newline at end of file diff --git a/syn/token/struct.Mod.html b/syn/token/struct.Mod.html index e371438..0cf27ea 100644 --- a/syn/token/struct.Mod.html +++ b/syn/token/struct.Mod.html @@ -1,37 +1,38 @@ -syn::token::Mod - Rust +syn::token::Mod - Rust -

    [−][src]Struct syn::token::Mod

    pub struct Mod {
+
    Struct syn::token::Mod[−][src]
    pub struct Mod {
     pub span: Span,
 }
    mod
    
-
    Don't try to remember the name of this type — use the
+
    Don’t try to remember the name of this type — use the
 Token! macro instead.
    
 
    
                        Fields
    span: Span
    Trait Implementations
    impl Clone for Mod[src]
    impl Copy for Mod[src]
    impl Debug for Mod[src]
    impl Default for Mod[src]
    impl Default for Mod[src]
    impl Eq for Mod[src]
    impl Hash for Mod[src]
    impl Parse for Mod[src]
    impl PartialEq<Mod> for Mod[src]
    impl ToTokens for Mod[src]
    impl Token for Mod[src]
    Auto Trait Implementations
    impl RefUnwindSafe for Mod[src]
    impl !Send for Mod[src]
    impl !Sync for Mod[src]
    impl Unpin for Mod[src]
    impl UnwindSafe for Mod[src]
    Blanket Implementations
    impl<T> Any for T where
        T: 'static + ?Sized,     [src]
    impl<T> Borrow<T> for T where
        T: ?Sized,     [src]
    impl<T> BorrowMut<T> for T where
        T: ?Sized,     [src]
    impl<T> From<T> for T[src]
    impl<T, U> Into<U> for T where
        U: From<T>,     [src]
    impl Token for Mod[src]
    Auto Trait Implementations
    impl RefUnwindSafe for Mod
    impl !Send for Mod
    impl !Sync for Mod
    impl Unpin for Mod
    impl UnwindSafe for Mod
    Blanket Implementations
    impl<T> Any for T where
        T: 'static + ?Sized,     [src]
    impl<T> Borrow<T> for T where
        T: ?Sized,     [src]
    impl<T> BorrowMut<T> for T where
        T: ?Sized,     [src]
    impl<T> From<T> for T[src]
    impl<T, U> Into<U> for T where
        U: From<T>,     [src]
    impl<T> Spanned for T where
        T: Spanned + ?Sized,     [src]
    impl<T> ToOwned for T where
        T: Clone,     [src]
    type Owned = T
    The resulting type after obtaining ownership.
    
-
    impl<T> ToOwned for T where
        T: Clone,     [src]
    type Owned = T
    The resulting type after obtaining ownership.
    
+
    impl<T, U> TryFrom<U> for T where
        U: Into<T>,     [src]
    type Error = Infallible
    The type returned in the event of a conversion error.
    
-
    impl<T, U> TryInto<U> for T where
        U: TryFrom<T>,     [src]
    type Error = <U as TryFrom<T>>::Error
    The type returned in the event of a conversion error.
    
-
    
\ No newline at end of file
+

    impl<T, U> TryFrom<U> for T where
        U: Into<T>,     [src]

    type Error = Infallible

    The type returned in the event of a conversion error.

    +

    impl<T, U> TryInto<U> for T where
        U: TryFrom<T>,     [src]

    type Error = <U as TryFrom<T>>::Error

    The type returned in the event of a conversion error.

    +
    + \ No newline at end of file diff --git a/syn/token/struct.Move.html b/syn/token/struct.Move.html index 6e32688..5320a84 100644 --- a/syn/token/struct.Move.html +++ b/syn/token/struct.Move.html @@ -1,37 +1,38 @@ -syn::token::Move - Rust +syn::token::Move - Rust -

    [−][src]Struct syn::token::Move

    pub struct Move {
+
    Struct syn::token::Move[−][src]
    pub struct Move {
     pub span: Span,
 }
    move
    
-
    Don't try to remember the name of this type — use the
+
    Don’t try to remember the name of this type — use the
 Token! macro instead.
    
 
    
                        Fields
    span: Span
    Trait Implementations
    impl Clone for Move[src]
    impl Copy for Move[src]
    impl Debug for Move[src]
    impl Default for Move[src]
    impl Default for Move[src]
    impl Eq for Move[src]
    impl Hash for Move[src]
    impl Parse for Move[src]
    impl PartialEq<Move> for Move[src]
    impl ToTokens for Move[src]
    impl Token for Move[src]
    Auto Trait Implementations
    Blanket Implementations
    impl<T> Any for T where
        T: 'static + ?Sized,     [src]
    impl<T> Borrow<T> for T where
        T: ?Sized,     [src]
    impl<T> BorrowMut<T> for T where
        T: ?Sized,     [src]
    impl<T> From<T> for T[src]
    impl<T, U> Into<U> for T where
        U: From<T>,     [src]
    impl Token for Move[src]
    Auto Trait Implementations
    impl RefUnwindSafe for Move
    impl !Send for Move
    impl !Sync for Move
    impl Unpin for Move
    impl UnwindSafe for Move
    Blanket Implementations
    impl<T> Any for T where
        T: 'static + ?Sized,     [src]
    impl<T> Borrow<T> for T where
        T: ?Sized,     [src]
    impl<T> BorrowMut<T> for T where
        T: ?Sized,     [src]
    impl<T> From<T> for T[src]
    impl<T, U> Into<U> for T where
        U: From<T>,     [src]
    impl<T> Spanned for T where
        T: Spanned + ?Sized,     [src]
    impl<T> ToOwned for T where
        T: Clone,     [src]
    type Owned = T
    The resulting type after obtaining ownership.
    
-
    impl<T> ToOwned for T where
        T: Clone,     [src]
    type Owned = T
    The resulting type after obtaining ownership.
    
+
    impl<T, U> TryFrom<U> for T where
        U: Into<T>,     [src]
    type Error = Infallible
    The type returned in the event of a conversion error.
    
-
    impl<T, U> TryInto<U> for T where
        U: TryFrom<T>,     [src]
    type Error = <U as TryFrom<T>>::Error
    The type returned in the event of a conversion error.
    
-
    
\ No newline at end of file
+

    impl<T, U> TryFrom<U> for T where
        U: Into<T>,     [src]

    type Error = Infallible

    The type returned in the event of a conversion error.

    +

    impl<T, U> TryInto<U> for T where
        U: TryFrom<T>,     [src]

    type Error = <U as TryFrom<T>>::Error

    The type returned in the event of a conversion error.

    +
    + \ No newline at end of file diff --git a/syn/token/struct.MulEq.html b/syn/token/struct.MulEq.html index 7bcdd83..0356188 100644 --- a/syn/token/struct.MulEq.html +++ b/syn/token/struct.MulEq.html @@ -1,37 +1,38 @@ -syn::token::MulEq - Rust +syn::token::MulEq - Rust -

    [−][src]Struct syn::token::MulEq

    #[repr(C)]pub struct MulEq {
+
    Struct syn::token::MulEq[−][src]
    #[repr(C)]pub struct MulEq {
     pub spans: [Span; 2],
 }
    *=
    
-
    Don't try to remember the name of this type — use the
+
    Don’t try to remember the name of this type — use the
 Token! macro instead.
    
 
    
                        Fields
    spans: [Span; 2]
    Trait Implementations
    impl Clone for MulEq[src]
    impl Copy for MulEq[src]
    impl Debug for MulEq[src]
    impl Default for MulEq[src]
    impl Default for MulEq[src]
    impl Eq for MulEq[src]
    impl Hash for MulEq[src]
    impl Parse for MulEq[src]
    impl PartialEq<MulEq> for MulEq[src]
    impl ToTokens for MulEq[src]
    impl Token for MulEq[src]
    Auto Trait Implementations
    Blanket Implementations
    impl<T> Any for T where
        T: 'static + ?Sized,     [src]
    impl<T> Borrow<T> for T where
        T: ?Sized,     [src]
    impl<T> BorrowMut<T> for T where
        T: ?Sized,     [src]
    impl<T> From<T> for T[src]
    impl<T, U> Into<U> for T where
        U: From<T>,     [src]
    impl Token for MulEq[src]
    Auto Trait Implementations
    impl RefUnwindSafe for MulEq
    impl !Send for MulEq
    impl !Sync for MulEq
    impl Unpin for MulEq
    impl UnwindSafe for MulEq
    Blanket Implementations
    impl<T> Any for T where
        T: 'static + ?Sized,     [src]
    impl<T> Borrow<T> for T where
        T: ?Sized,     [src]
    impl<T> BorrowMut<T> for T where
        T: ?Sized,     [src]
    impl<T> From<T> for T[src]
    impl<T, U> Into<U> for T where
        U: From<T>,     [src]
    impl<T> Spanned for T where
        T: Spanned + ?Sized,     [src]
    impl<T> ToOwned for T where
        T: Clone,     [src]
    type Owned = T
    The resulting type after obtaining ownership.
    
-
    impl<T> ToOwned for T where
        T: Clone,     [src]
    type Owned = T
    The resulting type after obtaining ownership.
    
+
    impl<T, U> TryFrom<U> for T where
        U: Into<T>,     [src]
    type Error = Infallible
    The type returned in the event of a conversion error.
    
-
    impl<T, U> TryInto<U> for T where
        U: TryFrom<T>,     [src]
    type Error = <U as TryFrom<T>>::Error
    The type returned in the event of a conversion error.
    
-
    
\ No newline at end of file
+

    impl<T, U> TryFrom<U> for T where
        U: Into<T>,     [src]

    type Error = Infallible

    The type returned in the event of a conversion error.

    +

    impl<T, U> TryInto<U> for T where
        U: TryFrom<T>,     [src]

    type Error = <U as TryFrom<T>>::Error

    The type returned in the event of a conversion error.

    +
    + \ No newline at end of file diff --git a/syn/token/struct.Mut.html b/syn/token/struct.Mut.html index 9ab9ae5..91a06b8 100644 --- a/syn/token/struct.Mut.html +++ b/syn/token/struct.Mut.html @@ -1,37 +1,38 @@ -syn::token::Mut - Rust +syn::token::Mut - Rust -

    [−][src]Struct syn::token::Mut

    pub struct Mut {
+
    Struct syn::token::Mut[−][src]
    pub struct Mut {
     pub span: Span,
 }
    mut
    
-
    Don't try to remember the name of this type — use the
+
    Don’t try to remember the name of this type — use the
 Token! macro instead.
    
 
    
                        Fields
    span: Span
    Trait Implementations
    impl Clone for Mut[src]
    impl Copy for Mut[src]
    impl Debug for Mut[src]
    impl Default for Mut[src]
    impl Default for Mut[src]
    impl Eq for Mut[src]
    impl Hash for Mut[src]
    impl Parse for Mut[src]
    impl PartialEq<Mut> for Mut[src]
    impl ToTokens for Mut[src]
    impl Token for Mut[src]
    Auto Trait Implementations
    impl RefUnwindSafe for Mut[src]
    impl !Send for Mut[src]
    impl !Sync for Mut[src]
    impl Unpin for Mut[src]
    impl UnwindSafe for Mut[src]
    Blanket Implementations
    impl<T> Any for T where
        T: 'static + ?Sized,     [src]
    impl<T> Borrow<T> for T where
        T: ?Sized,     [src]
    impl<T> BorrowMut<T> for T where
        T: ?Sized,     [src]
    impl<T> From<T> for T[src]
    impl<T, U> Into<U> for T where
        U: From<T>,     [src]
    impl Token for Mut[src]
    Auto Trait Implementations
    impl RefUnwindSafe for Mut
    impl !Send for Mut
    impl !Sync for Mut
    impl Unpin for Mut
    impl UnwindSafe for Mut
    Blanket Implementations
    impl<T> Any for T where
        T: 'static + ?Sized,     [src]
    impl<T> Borrow<T> for T where
        T: ?Sized,     [src]
    impl<T> BorrowMut<T> for T where
        T: ?Sized,     [src]
    impl<T> From<T> for T[src]
    impl<T, U> Into<U> for T where
        U: From<T>,     [src]
    impl<T> Spanned for T where
        T: Spanned + ?Sized,     [src]
    impl<T> ToOwned for T where
        T: Clone,     [src]
    type Owned = T
    The resulting type after obtaining ownership.
    
-
    impl<T> ToOwned for T where
        T: Clone,     [src]
    type Owned = T
    The resulting type after obtaining ownership.
    
+
    impl<T, U> TryFrom<U> for T where
        U: Into<T>,     [src]
    type Error = Infallible
    The type returned in the event of a conversion error.
    
-
    impl<T, U> TryInto<U> for T where
        U: TryFrom<T>,     [src]
    type Error = <U as TryFrom<T>>::Error
    The type returned in the event of a conversion error.
    
-
    
\ No newline at end of file
+

    impl<T, U> TryFrom<U> for T where
        U: Into<T>,     [src]

    type Error = Infallible

    The type returned in the event of a conversion error.

    +

    impl<T, U> TryInto<U> for T where
        U: TryFrom<T>,     [src]

    type Error = <U as TryFrom<T>>::Error

    The type returned in the event of a conversion error.

    +
    + \ No newline at end of file diff --git a/syn/token/struct.Ne.html b/syn/token/struct.Ne.html index de2982e..3681fd5 100644 --- a/syn/token/struct.Ne.html +++ b/syn/token/struct.Ne.html @@ -1,37 +1,38 @@ -syn::token::Ne - Rust +syn::token::Ne - Rust -

    [−][src]Struct syn::token::Ne

    #[repr(C)]pub struct Ne {
+
    Struct syn::token::Ne[−][src]
    #[repr(C)]pub struct Ne {
     pub spans: [Span; 2],
 }
    !=
    
-
    Don't try to remember the name of this type — use the
+
    Don’t try to remember the name of this type — use the
 Token! macro instead.
    
 
    
                        Fields
    spans: [Span; 2]
    Trait Implementations
    impl Clone for Ne[src]
    impl Copy for Ne[src]
    impl Debug for Ne[src]
    impl Default for Ne[src]
    impl Default for Ne[src]
    impl Eq for Ne[src]
    impl Hash for Ne[src]
    impl Parse for Ne[src]
    impl PartialEq<Ne> for Ne[src]
    impl ToTokens for Ne[src]
    impl Token for Ne[src]
    Auto Trait Implementations
    impl RefUnwindSafe for Ne[src]
    impl !Send for Ne[src]
    impl !Sync for Ne[src]
    impl Unpin for Ne[src]
    impl UnwindSafe for Ne[src]
    Blanket Implementations
    impl<T> Any for T where
        T: 'static + ?Sized,     [src]
    impl<T> Borrow<T> for T where
        T: ?Sized,     [src]
    impl<T> BorrowMut<T> for T where
        T: ?Sized,     [src]
    impl<T> From<T> for T[src]
    impl<T, U> Into<U> for T where
        U: From<T>,     [src]
    impl Token for Ne[src]
    Auto Trait Implementations
    impl RefUnwindSafe for Ne
    impl !Send for Ne
    impl !Sync for Ne
    impl Unpin for Ne
    impl UnwindSafe for Ne
    Blanket Implementations
    impl<T> Any for T where
        T: 'static + ?Sized,     [src]
    impl<T> Borrow<T> for T where
        T: ?Sized,     [src]
    impl<T> BorrowMut<T> for T where
        T: ?Sized,     [src]
    impl<T> From<T> for T[src]
    impl<T, U> Into<U> for T where
        U: From<T>,     [src]
    impl<T> Spanned for T where
        T: Spanned + ?Sized,     [src]
    impl<T> ToOwned for T where
        T: Clone,     [src]
    type Owned = T
    The resulting type after obtaining ownership.
    
-
    impl<T> ToOwned for T where
        T: Clone,     [src]
    type Owned = T
    The resulting type after obtaining ownership.
    
+
    impl<T, U> TryFrom<U> for T where
        U: Into<T>,     [src]
    type Error = Infallible
    The type returned in the event of a conversion error.
    
-
    impl<T, U> TryInto<U> for T where
        U: TryFrom<T>,     [src]
    type Error = <U as TryFrom<T>>::Error
    The type returned in the event of a conversion error.
    
-
    
\ No newline at end of file
+

    impl<T, U> TryFrom<U> for T where
        U: Into<T>,     [src]

    type Error = Infallible

    The type returned in the event of a conversion error.

    +

    impl<T, U> TryInto<U> for T where
        U: TryFrom<T>,     [src]

    type Error = <U as TryFrom<T>>::Error

    The type returned in the event of a conversion error.

    +
    + \ No newline at end of file diff --git a/syn/token/struct.Or.html b/syn/token/struct.Or.html index e73968e..d35a201 100644 --- a/syn/token/struct.Or.html +++ b/syn/token/struct.Or.html @@ -1,40 +1,41 @@ -syn::token::Or - Rust +syn::token::Or - Rust -

    [−][src]Struct syn::token::Or

    #[repr(C)]pub struct Or {
+
    Struct syn::token::Or[−][src]
    #[repr(C)]pub struct Or {
     pub spans: [Span; 1],
 }
    |
    
-
    Don't try to remember the name of this type — use the
+
    Don’t try to remember the name of this type — use the
 Token! macro instead.
    
 
    
                        Fields
    spans: [Span; 1]
    Trait Implementations
    impl Clone for Or[src]
    impl Copy for Or[src]
    impl Debug for Or[src]
    impl Default for Or[src]
    impl Default for Or[src]
    impl Deref for Or[src]
    type Target = WithSpan
    The resulting type after dereferencing.
    
 
    impl DerefMut for Or[src]
    impl Eq for Or[src]
    impl Hash for Or[src]
    impl Parse for Or[src]
    impl PartialEq<Or> for Or[src]
    impl ToTokens for Or[src]
    impl Token for Or[src]
    Auto Trait Implementations
    impl RefUnwindSafe for Or[src]
    impl !Send for Or[src]
    impl !Sync for Or[src]
    impl Unpin for Or[src]
    impl UnwindSafe for Or[src]
    Blanket Implementations
    impl<T> Any for T where
        T: 'static + ?Sized,     [src]
    impl<T> Borrow<T> for T where
        T: ?Sized,     [src]
    impl<T> BorrowMut<T> for T where
        T: ?Sized,     [src]
    impl<T> From<T> for T[src]
    impl<T, U> Into<U> for T where
        U: From<T>,     [src]
    impl Token for Or[src]
    Auto Trait Implementations
    impl RefUnwindSafe for Or
    impl !Send for Or
    impl !Sync for Or
    impl Unpin for Or
    impl UnwindSafe for Or
    Blanket Implementations
    impl<T> Any for T where
        T: 'static + ?Sized,     [src]
    impl<T> Borrow<T> for T where
        T: ?Sized,     [src]
    impl<T> BorrowMut<T> for T where
        T: ?Sized,     [src]
    impl<T> From<T> for T[src]
    impl<T, U> Into<U> for T where
        U: From<T>,     [src]
    impl<T> Spanned for T where
        T: Spanned + ?Sized,     [src]
    impl<T> ToOwned for T where
        T: Clone,     [src]
    type Owned = T
    The resulting type after obtaining ownership.
    
-
    impl<T> ToOwned for T where
        T: Clone,     [src]
    type Owned = T
    The resulting type after obtaining ownership.
    
+
    impl<T, U> TryFrom<U> for T where
        U: Into<T>,     [src]
    type Error = Infallible
    The type returned in the event of a conversion error.
    
-
    impl<T, U> TryInto<U> for T where
        U: TryFrom<T>,     [src]
    type Error = <U as TryFrom<T>>::Error
    The type returned in the event of a conversion error.
    
-
    
\ No newline at end of file
+

    impl<T, U> TryFrom<U> for T where
        U: Into<T>,     [src]

    type Error = Infallible

    The type returned in the event of a conversion error.

    +

    impl<T, U> TryInto<U> for T where
        U: TryFrom<T>,     [src]

    type Error = <U as TryFrom<T>>::Error

    The type returned in the event of a conversion error.

    +
    + \ No newline at end of file diff --git a/syn/token/struct.OrEq.html b/syn/token/struct.OrEq.html index 914ddc3..d2f8d0d 100644 --- a/syn/token/struct.OrEq.html +++ b/syn/token/struct.OrEq.html @@ -1,37 +1,38 @@ -syn::token::OrEq - Rust +syn::token::OrEq - Rust -

    [−][src]Struct syn::token::OrEq

    #[repr(C)]pub struct OrEq {
+
    Struct syn::token::OrEq[−][src]
    #[repr(C)]pub struct OrEq {
     pub spans: [Span; 2],
 }
    |=
    
-
    Don't try to remember the name of this type — use the
+
    Don’t try to remember the name of this type — use the
 Token! macro instead.
    
 
    
                        Fields
    spans: [Span; 2]
    Trait Implementations
    impl Clone for OrEq[src]
    impl Copy for OrEq[src]
    impl Debug for OrEq[src]
    impl Default for OrEq[src]
    impl Default for OrEq[src]
    impl Eq for OrEq[src]
    impl Hash for OrEq[src]
    impl Parse for OrEq[src]
    impl PartialEq<OrEq> for OrEq[src]
    impl ToTokens for OrEq[src]
    impl Token for OrEq[src]
    Auto Trait Implementations
    Blanket Implementations
    impl<T> Any for T where
        T: 'static + ?Sized,     [src]
    impl<T> Borrow<T> for T where
        T: ?Sized,     [src]
    impl<T> BorrowMut<T> for T where
        T: ?Sized,     [src]
    impl<T> From<T> for T[src]
    impl<T, U> Into<U> for T where
        U: From<T>,     [src]
    impl Token for OrEq[src]
    Auto Trait Implementations
    impl RefUnwindSafe for OrEq
    impl !Send for OrEq
    impl !Sync for OrEq
    impl Unpin for OrEq
    impl UnwindSafe for OrEq
    Blanket Implementations
    impl<T> Any for T where
        T: 'static + ?Sized,     [src]
    impl<T> Borrow<T> for T where
        T: ?Sized,     [src]
    impl<T> BorrowMut<T> for T where
        T: ?Sized,     [src]
    impl<T> From<T> for T[src]
    impl<T, U> Into<U> for T where
        U: From<T>,     [src]
    impl<T> Spanned for T where
        T: Spanned + ?Sized,     [src]
    impl<T> ToOwned for T where
        T: Clone,     [src]
    type Owned = T
    The resulting type after obtaining ownership.
    
-
    impl<T> ToOwned for T where
        T: Clone,     [src]
    type Owned = T
    The resulting type after obtaining ownership.
    
+
    impl<T, U> TryFrom<U> for T where
        U: Into<T>,     [src]
    type Error = Infallible
    The type returned in the event of a conversion error.
    
-
    impl<T, U> TryInto<U> for T where
        U: TryFrom<T>,     [src]
    type Error = <U as TryFrom<T>>::Error
    The type returned in the event of a conversion error.
    
-
    
\ No newline at end of file
+

    impl<T, U> TryFrom<U> for T where
        U: Into<T>,     [src]

    type Error = Infallible

    The type returned in the event of a conversion error.

    +

    impl<T, U> TryInto<U> for T where
        U: TryFrom<T>,     [src]

    type Error = <U as TryFrom<T>>::Error

    The type returned in the event of a conversion error.

    +
    + \ No newline at end of file diff --git a/syn/token/struct.OrOr.html b/syn/token/struct.OrOr.html index 9f8db03..11ae02d 100644 --- a/syn/token/struct.OrOr.html +++ b/syn/token/struct.OrOr.html @@ -1,37 +1,38 @@ -syn::token::OrOr - Rust +syn::token::OrOr - Rust -

    [−][src]Struct syn::token::OrOr

    #[repr(C)]pub struct OrOr {
+
    Struct syn::token::OrOr[−][src]
    #[repr(C)]pub struct OrOr {
     pub spans: [Span; 2],
 }
    ||
    
-
    Don't try to remember the name of this type — use the
+
    Don’t try to remember the name of this type — use the
 Token! macro instead.
    
 
    
                        Fields
    spans: [Span; 2]
    Trait Implementations
    impl Clone for OrOr[src]
    impl Copy for OrOr[src]
    impl Debug for OrOr[src]
    impl Default for OrOr[src]
    impl Default for OrOr[src]
    impl Eq for OrOr[src]
    impl Hash for OrOr[src]
    impl Parse for OrOr[src]
    impl PartialEq<OrOr> for OrOr[src]
    impl ToTokens for OrOr[src]
    impl Token for OrOr[src]
    Auto Trait Implementations
    Blanket Implementations
    impl<T> Any for T where
        T: 'static + ?Sized,     [src]
    impl<T> Borrow<T> for T where
        T: ?Sized,     [src]
    impl<T> BorrowMut<T> for T where
        T: ?Sized,     [src]
    impl<T> From<T> for T[src]
    impl<T, U> Into<U> for T where
        U: From<T>,     [src]
    impl Token for OrOr[src]
    Auto Trait Implementations
    impl RefUnwindSafe for OrOr
    impl !Send for OrOr
    impl !Sync for OrOr
    impl Unpin for OrOr
    impl UnwindSafe for OrOr
    Blanket Implementations
    impl<T> Any for T where
        T: 'static + ?Sized,     [src]
    impl<T> Borrow<T> for T where
        T: ?Sized,     [src]
    impl<T> BorrowMut<T> for T where
        T: ?Sized,     [src]
    impl<T> From<T> for T[src]
    impl<T, U> Into<U> for T where
        U: From<T>,     [src]
    impl<T> Spanned for T where
        T: Spanned + ?Sized,     [src]
    impl<T> ToOwned for T where
        T: Clone,     [src]
    type Owned = T
    The resulting type after obtaining ownership.
    
-
    impl<T> ToOwned for T where
        T: Clone,     [src]
    type Owned = T
    The resulting type after obtaining ownership.
    
+
    impl<T, U> TryFrom<U> for T where
        U: Into<T>,     [src]
    type Error = Infallible
    The type returned in the event of a conversion error.
    
-
    impl<T, U> TryInto<U> for T where
        U: TryFrom<T>,     [src]
    type Error = <U as TryFrom<T>>::Error
    The type returned in the event of a conversion error.
    
-
    
\ No newline at end of file
+

    impl<T, U> TryFrom<U> for T where
        U: Into<T>,     [src]

    type Error = Infallible

    The type returned in the event of a conversion error.

    +

    impl<T, U> TryInto<U> for T where
        U: TryFrom<T>,     [src]

    type Error = <U as TryFrom<T>>::Error

    The type returned in the event of a conversion error.

    +
    + \ No newline at end of file diff --git a/syn/token/struct.Override.html b/syn/token/struct.Override.html index ea43fe6..167ff8f 100644 --- a/syn/token/struct.Override.html +++ b/syn/token/struct.Override.html @@ -1,37 +1,38 @@ -syn::token::Override - Rust +syn::token::Override - Rust -

    [−][src]Struct syn::token::Override

    pub struct Override {
+
    Struct syn::token::Override[−][src]
    pub struct Override {
     pub span: Span,
 }
    override
    
-
    Don't try to remember the name of this type — use the
+
    Don’t try to remember the name of this type — use the
 Token! macro instead.
    
 
    
                        Fields
    span: Span
    Trait Implementations
    impl Clone for Override[src]
    impl Copy for Override[src]
    impl Debug for Override[src]
    impl Default for Override[src]
    impl Default for Override[src]
    impl Eq for Override[src]
    impl Hash for Override[src]
    impl Parse for Override[src]
    impl PartialEq<Override> for Override[src]
    impl ToTokens for Override[src]
    impl Token for Override[src]
    Auto Trait Implementations
    Blanket Implementations
    impl<T> Any for T where
        T: 'static + ?Sized,     [src]
    impl<T> Borrow<T> for T where
        T: ?Sized,     [src]
    impl<T> BorrowMut<T> for T where
        T: ?Sized,     [src]
    impl<T> From<T> for T[src]
    impl<T, U> Into<U> for T where
        U: From<T>,     [src]
    impl Token for Override[src]
    Auto Trait Implementations
    impl RefUnwindSafe for Override
    impl !Send for Override
    impl !Sync for Override
    impl Unpin for Override
    impl UnwindSafe for Override
    Blanket Implementations
    impl<T> Any for T where
        T: 'static + ?Sized,     [src]
    impl<T> Borrow<T> for T where
        T: ?Sized,     [src]
    impl<T> BorrowMut<T> for T where
        T: ?Sized,     [src]
    impl<T> From<T> for T[src]
    impl<T, U> Into<U> for T where
        U: From<T>,     [src]
    impl<T> Spanned for T where
        T: Spanned + ?Sized,     [src]
    impl<T> ToOwned for T where
        T: Clone,     [src]
    type Owned = T
    The resulting type after obtaining ownership.
    
-
    impl<T> ToOwned for T where
        T: Clone,     [src]
    type Owned = T
    The resulting type after obtaining ownership.
    
+
    impl<T, U> TryFrom<U> for T where
        U: Into<T>,     [src]
    type Error = Infallible
    The type returned in the event of a conversion error.
    
-
    impl<T, U> TryInto<U> for T where
        U: TryFrom<T>,     [src]
    type Error = <U as TryFrom<T>>::Error
    The type returned in the event of a conversion error.
    
-
    
\ No newline at end of file
+

    impl<T, U> TryFrom<U> for T where
        U: Into<T>,     [src]

    type Error = Infallible

    The type returned in the event of a conversion error.

    +

    impl<T, U> TryInto<U> for T where
        U: TryFrom<T>,     [src]

    type Error = <U as TryFrom<T>>::Error

    The type returned in the event of a conversion error.

    +
    + \ No newline at end of file diff --git a/syn/token/struct.Paren.html b/syn/token/struct.Paren.html index d5c7130..1b989a4 100644 --- a/syn/token/struct.Paren.html +++ b/syn/token/struct.Paren.html @@ -1,30 +1,31 @@ -syn::token::Paren - Rust +syn::token::Paren - Rust -

    [−][src]Struct syn::token::Paren

    pub struct Paren {
+
    Struct syn::token::Paren[−][src]
    pub struct Paren {
     pub span: Span,
 }
    (...)
    
 
    
                        Fields
    span: Span
    Implementations
    impl Paren[src]
    pub fn surround<F>(&self, tokens: &mut TokenStream, f: F) where
        F: FnOnce(&mut TokenStream),     [src]
    Trait Implementations
    impl Clone for Paren[src]
    impl Copy for Paren[src]
    impl Debug for Paren[src]
    impl Default for Paren[src]
    impl Default for Paren[src]
    impl Eq for Paren[src]
    impl Hash for Paren[src]
    impl PartialEq<Paren> for Paren[src]
    impl Token for Paren[src]
    Auto Trait Implementations
    Blanket Implementations
    impl<T> Any for T where
        T: 'static + ?Sized,     [src]
    impl<T> Borrow<T> for T where
        T: ?Sized,     [src]
    impl<T> BorrowMut<T> for T where
        T: ?Sized,     [src]
    impl<T> From<T> for T[src]
    impl<T, U> Into<U> for T where
        U: From<T>,     [src]
    impl<T> ToOwned for T where
        T: Clone,     [src]
    type Owned = T
    The resulting type after obtaining ownership.
    
-
    impl Token for Paren[src]
    Auto Trait Implementations
    impl RefUnwindSafe for Paren
    impl !Send for Paren
    impl !Sync for Paren
    impl Unpin for Paren
    impl UnwindSafe for Paren
    Blanket Implementations
    impl<T> Any for T where
        T: 'static + ?Sized,     [src]
    impl<T> Borrow<T> for T where
        T: ?Sized,     [src]
    impl<T> BorrowMut<T> for T where
        T: ?Sized,     [src]
    impl<T> From<T> for T[src]
    impl<T, U> Into<U> for T where
        U: From<T>,     [src]
    impl<T> ToOwned for T where
        T: Clone,     [src]
    type Owned = T
    The resulting type after obtaining ownership.
    
+
    impl<T, U> TryFrom<U> for T where
        U: Into<T>,     [src]
    type Error = Infallible
    The type returned in the event of a conversion error.
    
-
    impl<T, U> TryInto<U> for T where
        U: TryFrom<T>,     [src]
    type Error = <U as TryFrom<T>>::Error
    The type returned in the event of a conversion error.
    
-
    
\ No newline at end of file
+

    impl<T, U> TryFrom<U> for T where
        U: Into<T>,     [src]

    type Error = Infallible

    The type returned in the event of a conversion error.

    +

    impl<T, U> TryInto<U> for T where
        U: TryFrom<T>,     [src]

    type Error = <U as TryFrom<T>>::Error

    The type returned in the event of a conversion error.

    +
    + \ No newline at end of file diff --git a/syn/token/struct.Pound.html b/syn/token/struct.Pound.html index 67c9801..1d2d719 100644 --- a/syn/token/struct.Pound.html +++ b/syn/token/struct.Pound.html @@ -1,40 +1,41 @@ -syn::token::Pound - Rust +syn::token::Pound - Rust -

    [−][src]Struct syn::token::Pound

    #[repr(C)]pub struct Pound {
+
    Struct syn::token::Pound[−][src]
    #[repr(C)]pub struct Pound {
     pub spans: [Span; 1],
 }
    #
    
-
    Don't try to remember the name of this type — use the
+
    Don’t try to remember the name of this type — use the
 Token! macro instead.
    
 
    
                        Fields
    spans: [Span; 1]
    Trait Implementations
    impl Clone for Pound[src]
    impl Copy for Pound[src]
    impl Debug for Pound[src]
    impl Default for Pound[src]
    impl Default for Pound[src]
    impl Deref for Pound[src]
    type Target = WithSpan
    The resulting type after dereferencing.
    
 
    impl DerefMut for Pound[src]
    impl Eq for Pound[src]
    impl Hash for Pound[src]
    impl Parse for Pound[src]
    impl PartialEq<Pound> for Pound[src]
    impl ToTokens for Pound[src]
    impl Token for Pound[src]
    Auto Trait Implementations
    Blanket Implementations
    impl<T> Any for T where
        T: 'static + ?Sized,     [src]
    impl<T> Borrow<T> for T where
        T: ?Sized,     [src]
    impl<T> BorrowMut<T> for T where
        T: ?Sized,     [src]
    impl<T> From<T> for T[src]
    impl<T, U> Into<U> for T where
        U: From<T>,     [src]
    impl Token for Pound[src]
    Auto Trait Implementations
    impl RefUnwindSafe for Pound
    impl !Send for Pound
    impl !Sync for Pound
    impl Unpin for Pound
    impl UnwindSafe for Pound
    Blanket Implementations
    impl<T> Any for T where
        T: 'static + ?Sized,     [src]
    impl<T> Borrow<T> for T where
        T: ?Sized,     [src]
    impl<T> BorrowMut<T> for T where
        T: ?Sized,     [src]
    impl<T> From<T> for T[src]
    impl<T, U> Into<U> for T where
        U: From<T>,     [src]
    impl<T> Spanned for T where
        T: Spanned + ?Sized,     [src]
    impl<T> ToOwned for T where
        T: Clone,     [src]
    type Owned = T
    The resulting type after obtaining ownership.
    
-
    impl<T> ToOwned for T where
        T: Clone,     [src]
    type Owned = T
    The resulting type after obtaining ownership.
    
+
    impl<T, U> TryFrom<U> for T where
        U: Into<T>,     [src]
    type Error = Infallible
    The type returned in the event of a conversion error.
    
-
    impl<T, U> TryInto<U> for T where
        U: TryFrom<T>,     [src]
    type Error = <U as TryFrom<T>>::Error
    The type returned in the event of a conversion error.
    
-
    
\ No newline at end of file
+

    impl<T, U> TryFrom<U> for T where
        U: Into<T>,     [src]

    type Error = Infallible

    The type returned in the event of a conversion error.

    +

    impl<T, U> TryInto<U> for T where
        U: TryFrom<T>,     [src]

    type Error = <U as TryFrom<T>>::Error

    The type returned in the event of a conversion error.

    +
    + \ No newline at end of file diff --git a/syn/token/struct.Priv.html b/syn/token/struct.Priv.html index 06e0834..8780f29 100644 --- a/syn/token/struct.Priv.html +++ b/syn/token/struct.Priv.html @@ -1,37 +1,38 @@ -syn::token::Priv - Rust +syn::token::Priv - Rust -

    [−][src]Struct syn::token::Priv

    pub struct Priv {
+
    Struct syn::token::Priv[−][src]
    pub struct Priv {
     pub span: Span,
 }
    priv
    
-
    Don't try to remember the name of this type — use the
+
    Don’t try to remember the name of this type — use the
 Token! macro instead.
    
 
    
                        Fields
    span: Span
    Trait Implementations
    impl Clone for Priv[src]
    impl Copy for Priv[src]
    impl Debug for Priv[src]
    impl Default for Priv[src]
    impl Default for Priv[src]
    impl Eq for Priv[src]
    impl Hash for Priv[src]
    impl Parse for Priv[src]
    impl PartialEq<Priv> for Priv[src]
    impl ToTokens for Priv[src]
    impl Token for Priv[src]
    Auto Trait Implementations
    Blanket Implementations
    impl<T> Any for T where
        T: 'static + ?Sized,     [src]
    impl<T> Borrow<T> for T where
        T: ?Sized,     [src]
    impl<T> BorrowMut<T> for T where
        T: ?Sized,     [src]
    impl<T> From<T> for T[src]
    impl<T, U> Into<U> for T where
        U: From<T>,     [src]
    impl Token for Priv[src]
    Auto Trait Implementations
    impl RefUnwindSafe for Priv
    impl !Send for Priv
    impl !Sync for Priv
    impl Unpin for Priv
    impl UnwindSafe for Priv
    Blanket Implementations
    impl<T> Any for T where
        T: 'static + ?Sized,     [src]
    impl<T> Borrow<T> for T where
        T: ?Sized,     [src]
    impl<T> BorrowMut<T> for T where
        T: ?Sized,     [src]
    impl<T> From<T> for T[src]
    impl<T, U> Into<U> for T where
        U: From<T>,     [src]
    impl<T> Spanned for T where
        T: Spanned + ?Sized,     [src]
    impl<T> ToOwned for T where
        T: Clone,     [src]
    type Owned = T
    The resulting type after obtaining ownership.
    
-
    impl<T> ToOwned for T where
        T: Clone,     [src]
    type Owned = T
    The resulting type after obtaining ownership.
    
+
    impl<T, U> TryFrom<U> for T where
        U: Into<T>,     [src]
    type Error = Infallible
    The type returned in the event of a conversion error.
    
-
    impl<T, U> TryInto<U> for T where
        U: TryFrom<T>,     [src]
    type Error = <U as TryFrom<T>>::Error
    The type returned in the event of a conversion error.
    
-
    
\ No newline at end of file
+

    impl<T, U> TryFrom<U> for T where
        U: Into<T>,     [src]

    type Error = Infallible

    The type returned in the event of a conversion error.

    +

    impl<T, U> TryInto<U> for T where
        U: TryFrom<T>,     [src]

    type Error = <U as TryFrom<T>>::Error

    The type returned in the event of a conversion error.

    +
    + \ No newline at end of file diff --git a/syn/token/struct.Pub.html b/syn/token/struct.Pub.html index a556e74..3c87e97 100644 --- a/syn/token/struct.Pub.html +++ b/syn/token/struct.Pub.html @@ -1,37 +1,38 @@ -syn::token::Pub - Rust +syn::token::Pub - Rust -

    [−][src]Struct syn::token::Pub

    pub struct Pub {
+
    Struct syn::token::Pub[−][src]
    pub struct Pub {
     pub span: Span,
 }
    pub
    
-
    Don't try to remember the name of this type — use the
+
    Don’t try to remember the name of this type — use the
 Token! macro instead.
    
 
    
                        Fields
    span: Span
    Trait Implementations
    impl Clone for Pub[src]
    impl Copy for Pub[src]
    impl Debug for Pub[src]
    impl Default for Pub[src]
    impl Default for Pub[src]
    impl Eq for Pub[src]
    impl Hash for Pub[src]
    impl Parse for Pub[src]
    impl PartialEq<Pub> for Pub[src]
    impl ToTokens for Pub[src]
    impl Token for Pub[src]
    Auto Trait Implementations
    impl RefUnwindSafe for Pub[src]
    impl !Send for Pub[src]
    impl !Sync for Pub[src]
    impl Unpin for Pub[src]
    impl UnwindSafe for Pub[src]
    Blanket Implementations
    impl<T> Any for T where
        T: 'static + ?Sized,     [src]
    impl<T> Borrow<T> for T where
        T: ?Sized,     [src]
    impl<T> BorrowMut<T> for T where
        T: ?Sized,     [src]
    impl<T> From<T> for T[src]
    impl<T, U> Into<U> for T where
        U: From<T>,     [src]
    impl Token for Pub[src]
    Auto Trait Implementations
    impl RefUnwindSafe for Pub
    impl !Send for Pub
    impl !Sync for Pub
    impl Unpin for Pub
    impl UnwindSafe for Pub
    Blanket Implementations
    impl<T> Any for T where
        T: 'static + ?Sized,     [src]
    impl<T> Borrow<T> for T where
        T: ?Sized,     [src]
    impl<T> BorrowMut<T> for T where
        T: ?Sized,     [src]
    impl<T> From<T> for T[src]
    impl<T, U> Into<U> for T where
        U: From<T>,     [src]
    impl<T> Spanned for T where
        T: Spanned + ?Sized,     [src]
    impl<T> ToOwned for T where
        T: Clone,     [src]
    type Owned = T
    The resulting type after obtaining ownership.
    
-
    impl<T> ToOwned for T where
        T: Clone,     [src]
    type Owned = T
    The resulting type after obtaining ownership.
    
+
    impl<T, U> TryFrom<U> for T where
        U: Into<T>,     [src]
    type Error = Infallible
    The type returned in the event of a conversion error.
    
-
    impl<T, U> TryInto<U> for T where
        U: TryFrom<T>,     [src]
    type Error = <U as TryFrom<T>>::Error
    The type returned in the event of a conversion error.
    
-
    
\ No newline at end of file
+

    impl<T, U> TryFrom<U> for T where
        U: Into<T>,     [src]

    type Error = Infallible

    The type returned in the event of a conversion error.

    +

    impl<T, U> TryInto<U> for T where
        U: TryFrom<T>,     [src]

    type Error = <U as TryFrom<T>>::Error

    The type returned in the event of a conversion error.

    +
    + \ No newline at end of file diff --git a/syn/token/struct.Question.html b/syn/token/struct.Question.html index 6a4def6..2d010f9 100644 --- a/syn/token/struct.Question.html +++ b/syn/token/struct.Question.html @@ -1,40 +1,41 @@ -syn::token::Question - Rust +syn::token::Question - Rust -

    [−][src]Struct syn::token::Question

    #[repr(C)]pub struct Question {
+
    Struct syn::token::Question[−][src]
    #[repr(C)]pub struct Question {
     pub spans: [Span; 1],
 }
    ?
    
-
    Don't try to remember the name of this type — use the
+
    Don’t try to remember the name of this type — use the
 Token! macro instead.
    
 
    
                        Fields
    spans: [Span; 1]
    Trait Implementations
    impl Clone for Question[src]
    impl Copy for Question[src]
    impl Debug for Question[src]
    impl Default for Question[src]
    impl Default for Question[src]
    impl Deref for Question[src]
    type Target = WithSpan
    The resulting type after dereferencing.
    
 
    impl DerefMut for Question[src]
    impl Eq for Question[src]
    impl Hash for Question[src]
    impl Parse for Question[src]
    impl PartialEq<Question> for Question[src]
    impl ToTokens for Question[src]
    impl Token for Question[src]
    Auto Trait Implementations
    Blanket Implementations
    impl<T> Any for T where
        T: 'static + ?Sized,     [src]
    impl<T> Borrow<T> for T where
        T: ?Sized,     [src]
    impl<T> BorrowMut<T> for T where
        T: ?Sized,     [src]
    impl<T> From<T> for T[src]
    impl<T, U> Into<U> for T where
        U: From<T>,     [src]
    impl Token for Question[src]
    Auto Trait Implementations
    impl RefUnwindSafe for Question
    impl !Send for Question
    impl !Sync for Question
    impl Unpin for Question
    impl UnwindSafe for Question
    Blanket Implementations
    impl<T> Any for T where
        T: 'static + ?Sized,     [src]
    impl<T> Borrow<T> for T where
        T: ?Sized,     [src]
    impl<T> BorrowMut<T> for T where
        T: ?Sized,     [src]
    impl<T> From<T> for T[src]
    impl<T, U> Into<U> for T where
        U: From<T>,     [src]
    impl<T> Spanned for T where
        T: Spanned + ?Sized,     [src]
    impl<T> ToOwned for T where
        T: Clone,     [src]
    type Owned = T
    The resulting type after obtaining ownership.
    
-
    impl<T> ToOwned for T where
        T: Clone,     [src]
    type Owned = T
    The resulting type after obtaining ownership.
    
+
    impl<T, U> TryFrom<U> for T where
        U: Into<T>,     [src]
    type Error = Infallible
    The type returned in the event of a conversion error.
    
-
    impl<T, U> TryInto<U> for T where
        U: TryFrom<T>,     [src]
    type Error = <U as TryFrom<T>>::Error
    The type returned in the event of a conversion error.
    
-
    
\ No newline at end of file
+

    impl<T, U> TryFrom<U> for T where
        U: Into<T>,     [src]

    type Error = Infallible

    The type returned in the event of a conversion error.

    +

    impl<T, U> TryInto<U> for T where
        U: TryFrom<T>,     [src]

    type Error = <U as TryFrom<T>>::Error

    The type returned in the event of a conversion error.

    +
    + \ No newline at end of file diff --git a/syn/token/struct.RArrow.html b/syn/token/struct.RArrow.html index 13e9a13..f294abb 100644 --- a/syn/token/struct.RArrow.html +++ b/syn/token/struct.RArrow.html @@ -1,37 +1,38 @@ -syn::token::RArrow - Rust +syn::token::RArrow - Rust -

    [−][src]Struct syn::token::RArrow

    #[repr(C)]pub struct RArrow {
+
    Struct syn::token::RArrow[−][src]
    #[repr(C)]pub struct RArrow {
     pub spans: [Span; 2],
 }
    ->
    
-
    Don't try to remember the name of this type — use the
+
    Don’t try to remember the name of this type — use the
 Token! macro instead.
    
 
    
                        Fields
    spans: [Span; 2]
    Trait Implementations
    impl Clone for RArrow[src]
    impl Copy for RArrow[src]
    impl Debug for RArrow[src]
    impl Default for RArrow[src]
    impl Default for RArrow[src]
    impl Eq for RArrow[src]
    impl Hash for RArrow[src]
    impl Parse for RArrow[src]
    impl PartialEq<RArrow> for RArrow[src]
    impl ToTokens for RArrow[src]
    impl Token for RArrow[src]
    Auto Trait Implementations
    Blanket Implementations
    impl<T> Any for T where
        T: 'static + ?Sized,     [src]
    impl<T> Borrow<T> for T where
        T: ?Sized,     [src]
    impl<T> BorrowMut<T> for T where
        T: ?Sized,     [src]
    impl<T> From<T> for T[src]
    impl<T, U> Into<U> for T where
        U: From<T>,     [src]
    impl Token for RArrow[src]
    Auto Trait Implementations
    impl RefUnwindSafe for RArrow
    impl !Send for RArrow
    impl !Sync for RArrow
    impl Unpin for RArrow
    impl UnwindSafe for RArrow
    Blanket Implementations
    impl<T> Any for T where
        T: 'static + ?Sized,     [src]
    impl<T> Borrow<T> for T where
        T: ?Sized,     [src]
    impl<T> BorrowMut<T> for T where
        T: ?Sized,     [src]
    impl<T> From<T> for T[src]
    impl<T, U> Into<U> for T where
        U: From<T>,     [src]
    impl<T> Spanned for T where
        T: Spanned + ?Sized,     [src]
    impl<T> ToOwned for T where
        T: Clone,     [src]
    type Owned = T
    The resulting type after obtaining ownership.
    
-
    impl<T> ToOwned for T where
        T: Clone,     [src]
    type Owned = T
    The resulting type after obtaining ownership.
    
+
    impl<T, U> TryFrom<U> for T where
        U: Into<T>,     [src]
    type Error = Infallible
    The type returned in the event of a conversion error.
    
-
    impl<T, U> TryInto<U> for T where
        U: TryFrom<T>,     [src]
    type Error = <U as TryFrom<T>>::Error
    The type returned in the event of a conversion error.
    
-
    
\ No newline at end of file
+

    impl<T, U> TryFrom<U> for T where
        U: Into<T>,     [src]

    type Error = Infallible

    The type returned in the event of a conversion error.

    +

    impl<T, U> TryInto<U> for T where
        U: TryFrom<T>,     [src]

    type Error = <U as TryFrom<T>>::Error

    The type returned in the event of a conversion error.

    +
    + \ No newline at end of file diff --git a/syn/token/struct.Ref.html b/syn/token/struct.Ref.html index ff665a9..80820d4 100644 --- a/syn/token/struct.Ref.html +++ b/syn/token/struct.Ref.html @@ -1,37 +1,38 @@ -syn::token::Ref - Rust +syn::token::Ref - Rust -

    [−][src]Struct syn::token::Ref

    pub struct Ref {
+
    Struct syn::token::Ref[−][src]
    pub struct Ref {
     pub span: Span,
 }
    ref
    
-
    Don't try to remember the name of this type — use the
+
    Don’t try to remember the name of this type — use the
 Token! macro instead.
    
 
    
                        Fields
    span: Span
    Trait Implementations
    impl Clone for Ref[src]
    impl Copy for Ref[src]
    impl Debug for Ref[src]
    impl Default for Ref[src]
    impl Default for Ref[src]
    impl Eq for Ref[src]
    impl Hash for Ref[src]
    impl Parse for Ref[src]
    impl PartialEq<Ref> for Ref[src]
    impl ToTokens for Ref[src]
    impl Token for Ref[src]
    Auto Trait Implementations
    impl RefUnwindSafe for Ref[src]
    impl !Send for Ref[src]
    impl !Sync for Ref[src]
    impl Unpin for Ref[src]
    impl UnwindSafe for Ref[src]
    Blanket Implementations
    impl<T> Any for T where
        T: 'static + ?Sized,     [src]
    impl<T> Borrow<T> for T where
        T: ?Sized,     [src]
    impl<T> BorrowMut<T> for T where
        T: ?Sized,     [src]
    impl<T> From<T> for T[src]
    impl<T, U> Into<U> for T where
        U: From<T>,     [src]
    impl Token for Ref[src]
    Auto Trait Implementations
    impl RefUnwindSafe for Ref
    impl !Send for Ref
    impl !Sync for Ref
    impl Unpin for Ref
    impl UnwindSafe for Ref
    Blanket Implementations
    impl<T> Any for T where
        T: 'static + ?Sized,     [src]
    impl<T> Borrow<T> for T where
        T: ?Sized,     [src]
    impl<T> BorrowMut<T> for T where
        T: ?Sized,     [src]
    impl<T> From<T> for T[src]
    impl<T, U> Into<U> for T where
        U: From<T>,     [src]
    impl<T> Spanned for T where
        T: Spanned + ?Sized,     [src]
    impl<T> ToOwned for T where
        T: Clone,     [src]
    type Owned = T
    The resulting type after obtaining ownership.
    
-
    impl<T> ToOwned for T where
        T: Clone,     [src]
    type Owned = T
    The resulting type after obtaining ownership.
    
+
    impl<T, U> TryFrom<U> for T where
        U: Into<T>,     [src]
    type Error = Infallible
    The type returned in the event of a conversion error.
    
-
    impl<T, U> TryInto<U> for T where
        U: TryFrom<T>,     [src]
    type Error = <U as TryFrom<T>>::Error
    The type returned in the event of a conversion error.
    
-
    
\ No newline at end of file
+

    impl<T, U> TryFrom<U> for T where
        U: Into<T>,     [src]

    type Error = Infallible

    The type returned in the event of a conversion error.

    +

    impl<T, U> TryInto<U> for T where
        U: TryFrom<T>,     [src]

    type Error = <U as TryFrom<T>>::Error

    The type returned in the event of a conversion error.

    +
    + \ No newline at end of file diff --git a/syn/token/struct.Rem.html b/syn/token/struct.Rem.html index 82ab459..22eab28 100644 --- a/syn/token/struct.Rem.html +++ b/syn/token/struct.Rem.html @@ -1,40 +1,41 @@ -syn::token::Rem - Rust +syn::token::Rem - Rust -

    [−][src]Struct syn::token::Rem

    #[repr(C)]pub struct Rem {
+
    Struct syn::token::Rem[−][src]
    #[repr(C)]pub struct Rem {
     pub spans: [Span; 1],
 }
    %
    
-
    Don't try to remember the name of this type — use the
+
    Don’t try to remember the name of this type — use the
 Token! macro instead.
    
 
    
                        Fields
    spans: [Span; 1]
    Trait Implementations
    impl Clone for Rem[src]
    impl Copy for Rem[src]
    impl Debug for Rem[src]
    impl Default for Rem[src]
    impl Default for Rem[src]
    impl Deref for Rem[src]
    type Target = WithSpan
    The resulting type after dereferencing.
    
 
    impl DerefMut for Rem[src]
    impl Eq for Rem[src]
    impl Hash for Rem[src]
    impl Parse for Rem[src]
    impl PartialEq<Rem> for Rem[src]
    impl ToTokens for Rem[src]
    impl Token for Rem[src]
    Auto Trait Implementations
    impl RefUnwindSafe for Rem[src]
    impl !Send for Rem[src]
    impl !Sync for Rem[src]
    impl Unpin for Rem[src]
    impl UnwindSafe for Rem[src]
    Blanket Implementations
    impl<T> Any for T where
        T: 'static + ?Sized,     [src]
    impl<T> Borrow<T> for T where
        T: ?Sized,     [src]
    impl<T> BorrowMut<T> for T where
        T: ?Sized,     [src]
    impl<T> From<T> for T[src]
    impl<T, U> Into<U> for T where
        U: From<T>,     [src]
    impl Token for Rem[src]
    Auto Trait Implementations
    impl RefUnwindSafe for Rem
    impl !Send for Rem
    impl !Sync for Rem
    impl Unpin for Rem
    impl UnwindSafe for Rem
    Blanket Implementations
    impl<T> Any for T where
        T: 'static + ?Sized,     [src]
    impl<T> Borrow<T> for T where
        T: ?Sized,     [src]
    impl<T> BorrowMut<T> for T where
        T: ?Sized,     [src]
    impl<T> From<T> for T[src]
    impl<T, U> Into<U> for T where
        U: From<T>,     [src]
    impl<T> Spanned for T where
        T: Spanned + ?Sized,     [src]
    impl<T> ToOwned for T where
        T: Clone,     [src]
    type Owned = T
    The resulting type after obtaining ownership.
    
-
    impl<T> ToOwned for T where
        T: Clone,     [src]
    type Owned = T
    The resulting type after obtaining ownership.
    
+
    impl<T, U> TryFrom<U> for T where
        U: Into<T>,     [src]
    type Error = Infallible
    The type returned in the event of a conversion error.
    
-
    impl<T, U> TryInto<U> for T where
        U: TryFrom<T>,     [src]
    type Error = <U as TryFrom<T>>::Error
    The type returned in the event of a conversion error.
    
-
    
\ No newline at end of file
+

    impl<T, U> TryFrom<U> for T where
        U: Into<T>,     [src]

    type Error = Infallible

    The type returned in the event of a conversion error.

    +

    impl<T, U> TryInto<U> for T where
        U: TryFrom<T>,     [src]

    type Error = <U as TryFrom<T>>::Error

    The type returned in the event of a conversion error.

    +
    + \ No newline at end of file diff --git a/syn/token/struct.RemEq.html b/syn/token/struct.RemEq.html index 0869d0e..3caab5e 100644 --- a/syn/token/struct.RemEq.html +++ b/syn/token/struct.RemEq.html @@ -1,37 +1,38 @@ -syn::token::RemEq - Rust +syn::token::RemEq - Rust -

    [−][src]Struct syn::token::RemEq

    #[repr(C)]pub struct RemEq {
+
    Struct syn::token::RemEq[−][src]
    #[repr(C)]pub struct RemEq {
     pub spans: [Span; 2],
 }
    %=
    
-
    Don't try to remember the name of this type — use the
+
    Don’t try to remember the name of this type — use the
 Token! macro instead.
    
 
    
                        Fields
    spans: [Span; 2]
    Trait Implementations
    impl Clone for RemEq[src]
    impl Copy for RemEq[src]
    impl Debug for RemEq[src]
    impl Default for RemEq[src]
    impl Default for RemEq[src]
    impl Eq for RemEq[src]
    impl Hash for RemEq[src]
    impl Parse for RemEq[src]
    impl PartialEq<RemEq> for RemEq[src]
    impl ToTokens for RemEq[src]
    impl Token for RemEq[src]
    Auto Trait Implementations
    Blanket Implementations
    impl<T> Any for T where
        T: 'static + ?Sized,     [src]
    impl<T> Borrow<T> for T where
        T: ?Sized,     [src]
    impl<T> BorrowMut<T> for T where
        T: ?Sized,     [src]
    impl<T> From<T> for T[src]
    impl<T, U> Into<U> for T where
        U: From<T>,     [src]
    impl Token for RemEq[src]
    Auto Trait Implementations
    impl RefUnwindSafe for RemEq
    impl !Send for RemEq
    impl !Sync for RemEq
    impl Unpin for RemEq
    impl UnwindSafe for RemEq
    Blanket Implementations
    impl<T> Any for T where
        T: 'static + ?Sized,     [src]
    impl<T> Borrow<T> for T where
        T: ?Sized,     [src]
    impl<T> BorrowMut<T> for T where
        T: ?Sized,     [src]
    impl<T> From<T> for T[src]
    impl<T, U> Into<U> for T where
        U: From<T>,     [src]
    impl<T> Spanned for T where
        T: Spanned + ?Sized,     [src]
    impl<T> ToOwned for T where
        T: Clone,     [src]
    type Owned = T
    The resulting type after obtaining ownership.
    
-
    impl<T> ToOwned for T where
        T: Clone,     [src]
    type Owned = T
    The resulting type after obtaining ownership.
    
+
    impl<T, U> TryFrom<U> for T where
        U: Into<T>,     [src]
    type Error = Infallible
    The type returned in the event of a conversion error.
    
-
    impl<T, U> TryInto<U> for T where
        U: TryFrom<T>,     [src]
    type Error = <U as TryFrom<T>>::Error
    The type returned in the event of a conversion error.
    
-
    
\ No newline at end of file
+

    impl<T, U> TryFrom<U> for T where
        U: Into<T>,     [src]

    type Error = Infallible

    The type returned in the event of a conversion error.

    +

    impl<T, U> TryInto<U> for T where
        U: TryFrom<T>,     [src]

    type Error = <U as TryFrom<T>>::Error

    The type returned in the event of a conversion error.

    +
    + \ No newline at end of file diff --git a/syn/token/struct.Return.html b/syn/token/struct.Return.html index 4117433..f58468d 100644 --- a/syn/token/struct.Return.html +++ b/syn/token/struct.Return.html @@ -1,37 +1,38 @@ -syn::token::Return - Rust +syn::token::Return - Rust -

    [−][src]Struct syn::token::Return

    pub struct Return {
+
    Struct syn::token::Return[−][src]
    pub struct Return {
     pub span: Span,
 }
    return
    
-
    Don't try to remember the name of this type — use the
+
    Don’t try to remember the name of this type — use the
 Token! macro instead.
    
 
    
                        Fields
    span: Span
    Trait Implementations
    impl Clone for Return[src]
    impl Copy for Return[src]
    impl Debug for Return[src]
    impl Default for Return[src]
    impl Default for Return[src]
    impl Eq for Return[src]
    impl Hash for Return[src]
    impl Parse for Return[src]
    impl PartialEq<Return> for Return[src]
    impl ToTokens for Return[src]
    impl Token for Return[src]
    Auto Trait Implementations
    Blanket Implementations
    impl<T> Any for T where
        T: 'static + ?Sized,     [src]
    impl<T> Borrow<T> for T where
        T: ?Sized,     [src]
    impl<T> BorrowMut<T> for T where
        T: ?Sized,     [src]
    impl<T> From<T> for T[src]
    impl<T, U> Into<U> for T where
        U: From<T>,     [src]
    impl Token for Return[src]
    Auto Trait Implementations
    impl RefUnwindSafe for Return
    impl !Send for Return
    impl !Sync for Return
    impl Unpin for Return
    impl UnwindSafe for Return
    Blanket Implementations
    impl<T> Any for T where
        T: 'static + ?Sized,     [src]
    impl<T> Borrow<T> for T where
        T: ?Sized,     [src]
    impl<T> BorrowMut<T> for T where
        T: ?Sized,     [src]
    impl<T> From<T> for T[src]
    impl<T, U> Into<U> for T where
        U: From<T>,     [src]
    impl<T> Spanned for T where
        T: Spanned + ?Sized,     [src]
    impl<T> ToOwned for T where
        T: Clone,     [src]
    type Owned = T
    The resulting type after obtaining ownership.
    
-
    impl<T> ToOwned for T where
        T: Clone,     [src]
    type Owned = T
    The resulting type after obtaining ownership.
    
+
    impl<T, U> TryFrom<U> for T where
        U: Into<T>,     [src]
    type Error = Infallible
    The type returned in the event of a conversion error.
    
-
    impl<T, U> TryInto<U> for T where
        U: TryFrom<T>,     [src]
    type Error = <U as TryFrom<T>>::Error
    The type returned in the event of a conversion error.
    
-
    
\ No newline at end of file
+

    impl<T, U> TryFrom<U> for T where
        U: Into<T>,     [src]

    type Error = Infallible

    The type returned in the event of a conversion error.

    +

    impl<T, U> TryInto<U> for T where
        U: TryFrom<T>,     [src]

    type Error = <U as TryFrom<T>>::Error

    The type returned in the event of a conversion error.

    +
    + \ No newline at end of file diff --git a/syn/token/struct.SelfType.html b/syn/token/struct.SelfType.html index b2d35b1..0d7e82f 100644 --- a/syn/token/struct.SelfType.html +++ b/syn/token/struct.SelfType.html @@ -1,38 +1,39 @@ -syn::token::SelfType - Rust +syn::token::SelfType - Rust -

    [−][src]Struct syn::token::SelfType

    pub struct SelfType {
+
    Struct syn::token::SelfType[−][src]
    pub struct SelfType {
     pub span: Span,
 }
    Self
    
-
    Don't try to remember the name of this type — use the
+
    Don’t try to remember the name of this type — use the
 Token! macro instead.
    
 
    
                        Fields
    span: Span
    Trait Implementations
    impl Clone for SelfType[src]
    impl Copy for SelfType[src]
    impl Debug for SelfType[src]
    impl Default for SelfType[src]
    impl Default for SelfType[src]
    impl Eq for SelfType[src]
    impl From<SelfType> for Ident[src]
    impl Hash for SelfType[src]
    impl Parse for SelfType[src]
    impl PartialEq<SelfType> for SelfType[src]
    impl ToTokens for SelfType[src]
    impl Token for SelfType[src]
    Auto Trait Implementations
    Blanket Implementations
    impl<T> Any for T where
        T: 'static + ?Sized,     [src]
    impl<T> Borrow<T> for T where
        T: ?Sized,     [src]
    impl<T> BorrowMut<T> for T where
        T: ?Sized,     [src]
    impl<T> From<T> for T[src]
    impl<T, U> Into<U> for T where
        U: From<T>,     [src]
    impl Token for SelfType[src]
    Auto Trait Implementations
    impl RefUnwindSafe for SelfType
    impl !Send for SelfType
    impl !Sync for SelfType
    impl Unpin for SelfType
    impl UnwindSafe for SelfType
    Blanket Implementations
    impl<T> Any for T where
        T: 'static + ?Sized,     [src]
    impl<T> Borrow<T> for T where
        T: ?Sized,     [src]
    impl<T> BorrowMut<T> for T where
        T: ?Sized,     [src]
    impl<T> From<T> for T[src]
    impl<T, U> Into<U> for T where
        U: From<T>,     [src]
    impl<T> Spanned for T where
        T: Spanned + ?Sized,     [src]
    impl<T> ToOwned for T where
        T: Clone,     [src]
    type Owned = T
    The resulting type after obtaining ownership.
    
-
    impl<T> ToOwned for T where
        T: Clone,     [src]
    type Owned = T
    The resulting type after obtaining ownership.
    
+
    impl<T, U> TryFrom<U> for T where
        U: Into<T>,     [src]
    type Error = Infallible
    The type returned in the event of a conversion error.
    
-
    impl<T, U> TryInto<U> for T where
        U: TryFrom<T>,     [src]
    type Error = <U as TryFrom<T>>::Error
    The type returned in the event of a conversion error.
    
-
    
\ No newline at end of file
+

    impl<T, U> TryFrom<U> for T where
        U: Into<T>,     [src]

    type Error = Infallible

    The type returned in the event of a conversion error.

    +

    impl<T, U> TryInto<U> for T where
        U: TryFrom<T>,     [src]

    type Error = <U as TryFrom<T>>::Error

    The type returned in the event of a conversion error.

    +
    + \ No newline at end of file diff --git a/syn/token/struct.SelfValue.html b/syn/token/struct.SelfValue.html index bca6369..cf7dd55 100644 --- a/syn/token/struct.SelfValue.html +++ b/syn/token/struct.SelfValue.html @@ -1,38 +1,39 @@ -syn::token::SelfValue - Rust +syn::token::SelfValue - Rust -

    [−][src]Struct syn::token::SelfValue

    pub struct SelfValue {
+
    Struct syn::token::SelfValue[−][src]
    pub struct SelfValue {
     pub span: Span,
 }
    self
    
-
    Don't try to remember the name of this type — use the
+
    Don’t try to remember the name of this type — use the
 Token! macro instead.
    
 
    
                        Fields
    span: Span
    Trait Implementations
    impl Clone for SelfValue[src]
    impl Copy for SelfValue[src]
    impl Debug for SelfValue[src]
    impl Default for SelfValue[src]
    impl Default for SelfValue[src]
    impl Eq for SelfValue[src]
    impl From<SelfValue> for Ident[src]
    impl Hash for SelfValue[src]
    impl Parse for SelfValue[src]
    impl PartialEq<SelfValue> for SelfValue[src]
    impl ToTokens for SelfValue[src]
    impl Token for SelfValue[src]
    Auto Trait Implementations
    Blanket Implementations
    impl<T> Any for T where
        T: 'static + ?Sized,     [src]
    impl<T> Borrow<T> for T where
        T: ?Sized,     [src]
    impl<T> BorrowMut<T> for T where
        T: ?Sized,     [src]
    impl<T> From<T> for T[src]
    impl<T, U> Into<U> for T where
        U: From<T>,     [src]
    impl Token for SelfValue[src]
    Auto Trait Implementations
    Blanket Implementations
    impl<T> Any for T where
        T: 'static + ?Sized,     [src]
    impl<T> Borrow<T> for T where
        T: ?Sized,     [src]
    impl<T> BorrowMut<T> for T where
        T: ?Sized,     [src]
    impl<T> From<T> for T[src]
    impl<T, U> Into<U> for T where
        U: From<T>,     [src]
    impl<T> Spanned for T where
        T: Spanned + ?Sized,     [src]
    impl<T> ToOwned for T where
        T: Clone,     [src]
    type Owned = T
    The resulting type after obtaining ownership.
    
-
    impl<T> ToOwned for T where
        T: Clone,     [src]
    type Owned = T
    The resulting type after obtaining ownership.
    
+
    impl<T, U> TryFrom<U> for T where
        U: Into<T>,     [src]
    type Error = Infallible
    The type returned in the event of a conversion error.
    
-
    impl<T, U> TryInto<U> for T where
        U: TryFrom<T>,     [src]
    type Error = <U as TryFrom<T>>::Error
    The type returned in the event of a conversion error.
    
-
    
\ No newline at end of file
+

    impl<T, U> TryFrom<U> for T where
        U: Into<T>,     [src]

    type Error = Infallible

    The type returned in the event of a conversion error.

    +

    impl<T, U> TryInto<U> for T where
        U: TryFrom<T>,     [src]

    type Error = <U as TryFrom<T>>::Error

    The type returned in the event of a conversion error.

    +
    + \ No newline at end of file diff --git a/syn/token/struct.Semi.html b/syn/token/struct.Semi.html index e0b491b..7f64c5b 100644 --- a/syn/token/struct.Semi.html +++ b/syn/token/struct.Semi.html @@ -1,40 +1,41 @@ -syn::token::Semi - Rust +syn::token::Semi - Rust -

    [−][src]Struct syn::token::Semi

    #[repr(C)]pub struct Semi {
+
    Struct syn::token::Semi[−][src]
    #[repr(C)]pub struct Semi {
     pub spans: [Span; 1],
 }
    ;
    
-
    Don't try to remember the name of this type — use the
+
    Don’t try to remember the name of this type — use the
 Token! macro instead.
    
 
    
                        Fields
    spans: [Span; 1]
    Trait Implementations
    impl Clone for Semi[src]
    impl Copy for Semi[src]
    impl Debug for Semi[src]
    impl Default for Semi[src]
    impl Default for Semi[src]
    impl Deref for Semi[src]
    type Target = WithSpan
    The resulting type after dereferencing.
    
 
    impl DerefMut for Semi[src]
    impl Eq for Semi[src]
    impl Hash for Semi[src]
    impl Parse for Semi[src]
    impl PartialEq<Semi> for Semi[src]
    impl ToTokens for Semi[src]
    impl Token for Semi[src]
    Auto Trait Implementations
    Blanket Implementations
    impl<T> Any for T where
        T: 'static + ?Sized,     [src]
    impl<T> Borrow<T> for T where
        T: ?Sized,     [src]
    impl<T> BorrowMut<T> for T where
        T: ?Sized,     [src]
    impl<T> From<T> for T[src]
    impl<T, U> Into<U> for T where
        U: From<T>,     [src]
    impl Token for Semi[src]
    Auto Trait Implementations
    impl RefUnwindSafe for Semi
    impl !Send for Semi
    impl !Sync for Semi
    impl Unpin for Semi
    impl UnwindSafe for Semi
    Blanket Implementations
    impl<T> Any for T where
        T: 'static + ?Sized,     [src]
    impl<T> Borrow<T> for T where
        T: ?Sized,     [src]
    impl<T> BorrowMut<T> for T where
        T: ?Sized,     [src]
    impl<T> From<T> for T[src]
    impl<T, U> Into<U> for T where
        U: From<T>,     [src]
    impl<T> Spanned for T where
        T: Spanned + ?Sized,     [src]
    impl<T> ToOwned for T where
        T: Clone,     [src]
    type Owned = T
    The resulting type after obtaining ownership.
    
-
    impl<T> ToOwned for T where
        T: Clone,     [src]
    type Owned = T
    The resulting type after obtaining ownership.
    
+
    impl<T, U> TryFrom<U> for T where
        U: Into<T>,     [src]
    type Error = Infallible
    The type returned in the event of a conversion error.
    
-
    impl<T, U> TryInto<U> for T where
        U: TryFrom<T>,     [src]
    type Error = <U as TryFrom<T>>::Error
    The type returned in the event of a conversion error.
    
-
    
\ No newline at end of file
+

    impl<T, U> TryFrom<U> for T where
        U: Into<T>,     [src]

    type Error = Infallible

    The type returned in the event of a conversion error.

    +

    impl<T, U> TryInto<U> for T where
        U: TryFrom<T>,     [src]

    type Error = <U as TryFrom<T>>::Error

    The type returned in the event of a conversion error.

    +
    + \ No newline at end of file diff --git a/syn/token/struct.Shl.html b/syn/token/struct.Shl.html index 6d8ae0e..5e4ce4f 100644 --- a/syn/token/struct.Shl.html +++ b/syn/token/struct.Shl.html @@ -1,37 +1,38 @@ -syn::token::Shl - Rust +syn::token::Shl - Rust -

    [−][src]Struct syn::token::Shl

    #[repr(C)]pub struct Shl {
+
    Struct syn::token::Shl[−][src]
    #[repr(C)]pub struct Shl {
     pub spans: [Span; 2],
 }
    <<
    
-
    Don't try to remember the name of this type — use the
+
    Don’t try to remember the name of this type — use the
 Token! macro instead.
    
 
    
                        Fields
    spans: [Span; 2]
    Trait Implementations
    impl Clone for Shl[src]
    impl Copy for Shl[src]
    impl Debug for Shl[src]
    impl Default for Shl[src]
    impl Default for Shl[src]
    impl Eq for Shl[src]
    impl Hash for Shl[src]
    impl Parse for Shl[src]
    impl PartialEq<Shl> for Shl[src]
    impl ToTokens for Shl[src]
    impl Token for Shl[src]
    Auto Trait Implementations
    impl RefUnwindSafe for Shl[src]
    impl !Send for Shl[src]
    impl !Sync for Shl[src]
    impl Unpin for Shl[src]
    impl UnwindSafe for Shl[src]
    Blanket Implementations
    impl<T> Any for T where
        T: 'static + ?Sized,     [src]
    impl<T> Borrow<T> for T where
        T: ?Sized,     [src]
    impl<T> BorrowMut<T> for T where
        T: ?Sized,     [src]
    impl<T> From<T> for T[src]
    impl<T, U> Into<U> for T where
        U: From<T>,     [src]
    impl Token for Shl[src]
    Auto Trait Implementations
    impl RefUnwindSafe for Shl
    impl !Send for Shl
    impl !Sync for Shl
    impl Unpin for Shl
    impl UnwindSafe for Shl
    Blanket Implementations
    impl<T> Any for T where
        T: 'static + ?Sized,     [src]
    impl<T> Borrow<T> for T where
        T: ?Sized,     [src]
    impl<T> BorrowMut<T> for T where
        T: ?Sized,     [src]
    impl<T> From<T> for T[src]
    impl<T, U> Into<U> for T where
        U: From<T>,     [src]
    impl<T> Spanned for T where
        T: Spanned + ?Sized,     [src]
    impl<T> ToOwned for T where
        T: Clone,     [src]
    type Owned = T
    The resulting type after obtaining ownership.
    
-
    impl<T> ToOwned for T where
        T: Clone,     [src]
    type Owned = T
    The resulting type after obtaining ownership.
    
+
    impl<T, U> TryFrom<U> for T where
        U: Into<T>,     [src]
    type Error = Infallible
    The type returned in the event of a conversion error.
    
-
    impl<T, U> TryInto<U> for T where
        U: TryFrom<T>,     [src]
    type Error = <U as TryFrom<T>>::Error
    The type returned in the event of a conversion error.
    
-
    
\ No newline at end of file
+

    impl<T, U> TryFrom<U> for T where
        U: Into<T>,     [src]

    type Error = Infallible

    The type returned in the event of a conversion error.

    +

    impl<T, U> TryInto<U> for T where
        U: TryFrom<T>,     [src]

    type Error = <U as TryFrom<T>>::Error

    The type returned in the event of a conversion error.

    +
    + \ No newline at end of file diff --git a/syn/token/struct.ShlEq.html b/syn/token/struct.ShlEq.html index 1ce1ba6..3f90716 100644 --- a/syn/token/struct.ShlEq.html +++ b/syn/token/struct.ShlEq.html @@ -1,37 +1,38 @@ -syn::token::ShlEq - Rust +syn::token::ShlEq - Rust -

    [−][src]Struct syn::token::ShlEq

    #[repr(C)]pub struct ShlEq {
+
    Struct syn::token::ShlEq[−][src]
    #[repr(C)]pub struct ShlEq {
     pub spans: [Span; 3],
 }
    <<=
    
-
    Don't try to remember the name of this type — use the
+
    Don’t try to remember the name of this type — use the
 Token! macro instead.
    
 
    
                        Fields
    spans: [Span; 3]
    Trait Implementations
    impl Clone for ShlEq[src]
    impl Copy for ShlEq[src]
    impl Debug for ShlEq[src]
    impl Default for ShlEq[src]
    impl Default for ShlEq[src]
    impl Eq for ShlEq[src]
    impl Hash for ShlEq[src]
    impl Parse for ShlEq[src]
    impl PartialEq<ShlEq> for ShlEq[src]
    impl ToTokens for ShlEq[src]
    impl Token for ShlEq[src]
    Auto Trait Implementations
    Blanket Implementations
    impl<T> Any for T where
        T: 'static + ?Sized,     [src]
    impl<T> Borrow<T> for T where
        T: ?Sized,     [src]
    impl<T> BorrowMut<T> for T where
        T: ?Sized,     [src]
    impl<T> From<T> for T[src]
    impl<T, U> Into<U> for T where
        U: From<T>,     [src]
    impl Token for ShlEq[src]
    Auto Trait Implementations
    impl RefUnwindSafe for ShlEq
    impl !Send for ShlEq
    impl !Sync for ShlEq
    impl Unpin for ShlEq
    impl UnwindSafe for ShlEq
    Blanket Implementations
    impl<T> Any for T where
        T: 'static + ?Sized,     [src]
    impl<T> Borrow<T> for T where
        T: ?Sized,     [src]
    impl<T> BorrowMut<T> for T where
        T: ?Sized,     [src]
    impl<T> From<T> for T[src]
    impl<T, U> Into<U> for T where
        U: From<T>,     [src]
    impl<T> Spanned for T where
        T: Spanned + ?Sized,     [src]
    impl<T> ToOwned for T where
        T: Clone,     [src]
    type Owned = T
    The resulting type after obtaining ownership.
    
-
    impl<T> ToOwned for T where
        T: Clone,     [src]
    type Owned = T
    The resulting type after obtaining ownership.
    
+
    impl<T, U> TryFrom<U> for T where
        U: Into<T>,     [src]
    type Error = Infallible
    The type returned in the event of a conversion error.
    
-
    impl<T, U> TryInto<U> for T where
        U: TryFrom<T>,     [src]
    type Error = <U as TryFrom<T>>::Error
    The type returned in the event of a conversion error.
    
-
    
\ No newline at end of file
+

    impl<T, U> TryFrom<U> for T where
        U: Into<T>,     [src]

    type Error = Infallible

    The type returned in the event of a conversion error.

    +

    impl<T, U> TryInto<U> for T where
        U: TryFrom<T>,     [src]

    type Error = <U as TryFrom<T>>::Error

    The type returned in the event of a conversion error.

    +
    + \ No newline at end of file diff --git a/syn/token/struct.Shr.html b/syn/token/struct.Shr.html index 5dfc1a8..b4f7c5d 100644 --- a/syn/token/struct.Shr.html +++ b/syn/token/struct.Shr.html @@ -1,37 +1,38 @@ -syn::token::Shr - Rust +syn::token::Shr - Rust -

    [−][src]Struct syn::token::Shr

    #[repr(C)]pub struct Shr {
+
    Struct syn::token::Shr[−][src]
    #[repr(C)]pub struct Shr {
     pub spans: [Span; 2],
 }
    >>
    
-
    Don't try to remember the name of this type — use the
+
    Don’t try to remember the name of this type — use the
 Token! macro instead.
    
 
    
                        Fields
    spans: [Span; 2]
    Trait Implementations
    impl Clone for Shr[src]
    impl Copy for Shr[src]
    impl Debug for Shr[src]
    impl Default for Shr[src]
    impl Default for Shr[src]
    impl Eq for Shr[src]
    impl Hash for Shr[src]
    impl Parse for Shr[src]
    impl PartialEq<Shr> for Shr[src]
    impl ToTokens for Shr[src]
    impl Token for Shr[src]
    Auto Trait Implementations
    impl RefUnwindSafe for Shr[src]
    impl !Send for Shr[src]
    impl !Sync for Shr[src]
    impl Unpin for Shr[src]
    impl UnwindSafe for Shr[src]
    Blanket Implementations
    impl<T> Any for T where
        T: 'static + ?Sized,     [src]
    impl<T> Borrow<T> for T where
        T: ?Sized,     [src]
    impl<T> BorrowMut<T> for T where
        T: ?Sized,     [src]
    impl<T> From<T> for T[src]
    impl<T, U> Into<U> for T where
        U: From<T>,     [src]
    impl Token for Shr[src]
    Auto Trait Implementations
    impl RefUnwindSafe for Shr
    impl !Send for Shr
    impl !Sync for Shr
    impl Unpin for Shr
    impl UnwindSafe for Shr
    Blanket Implementations
    impl<T> Any for T where
        T: 'static + ?Sized,     [src]
    impl<T> Borrow<T> for T where
        T: ?Sized,     [src]
    impl<T> BorrowMut<T> for T where
        T: ?Sized,     [src]
    impl<T> From<T> for T[src]
    impl<T, U> Into<U> for T where
        U: From<T>,     [src]
    impl<T> Spanned for T where
        T: Spanned + ?Sized,     [src]
    impl<T> ToOwned for T where
        T: Clone,     [src]
    type Owned = T
    The resulting type after obtaining ownership.
    
-
    impl<T> ToOwned for T where
        T: Clone,     [src]
    type Owned = T
    The resulting type after obtaining ownership.
    
+
    impl<T, U> TryFrom<U> for T where
        U: Into<T>,     [src]
    type Error = Infallible
    The type returned in the event of a conversion error.
    
-
    impl<T, U> TryInto<U> for T where
        U: TryFrom<T>,     [src]
    type Error = <U as TryFrom<T>>::Error
    The type returned in the event of a conversion error.
    
-
    
\ No newline at end of file
+

    impl<T, U> TryFrom<U> for T where
        U: Into<T>,     [src]

    type Error = Infallible

    The type returned in the event of a conversion error.

    +

    impl<T, U> TryInto<U> for T where
        U: TryFrom<T>,     [src]

    type Error = <U as TryFrom<T>>::Error

    The type returned in the event of a conversion error.

    +
    + \ No newline at end of file diff --git a/syn/token/struct.ShrEq.html b/syn/token/struct.ShrEq.html index 9958edb..a7e2a62 100644 --- a/syn/token/struct.ShrEq.html +++ b/syn/token/struct.ShrEq.html @@ -1,37 +1,38 @@ -syn::token::ShrEq - Rust +syn::token::ShrEq - Rust -

    [−][src]Struct syn::token::ShrEq

    #[repr(C)]pub struct ShrEq {
+
    Struct syn::token::ShrEq[−][src]
    #[repr(C)]pub struct ShrEq {
     pub spans: [Span; 3],
 }
    >>=
    
-
    Don't try to remember the name of this type — use the
+
    Don’t try to remember the name of this type — use the
 Token! macro instead.
    
 
    
                        Fields
    spans: [Span; 3]
    Trait Implementations
    impl Clone for ShrEq[src]
    impl Copy for ShrEq[src]
    impl Debug for ShrEq[src]
    impl Default for ShrEq[src]
    impl Default for ShrEq[src]
    impl Eq for ShrEq[src]
    impl Hash for ShrEq[src]
    impl Parse for ShrEq[src]
    impl PartialEq<ShrEq> for ShrEq[src]
    impl ToTokens for ShrEq[src]
    impl Token for ShrEq[src]
    Auto Trait Implementations
    Blanket Implementations
    impl<T> Any for T where
        T: 'static + ?Sized,     [src]
    impl<T> Borrow<T> for T where
        T: ?Sized,     [src]
    impl<T> BorrowMut<T> for T where
        T: ?Sized,     [src]
    impl<T> From<T> for T[src]
    impl<T, U> Into<U> for T where
        U: From<T>,     [src]
    impl Token for ShrEq[src]
    Auto Trait Implementations
    impl RefUnwindSafe for ShrEq
    impl !Send for ShrEq
    impl !Sync for ShrEq
    impl Unpin for ShrEq
    impl UnwindSafe for ShrEq
    Blanket Implementations
    impl<T> Any for T where
        T: 'static + ?Sized,     [src]
    impl<T> Borrow<T> for T where
        T: ?Sized,     [src]
    impl<T> BorrowMut<T> for T where
        T: ?Sized,     [src]
    impl<T> From<T> for T[src]
    impl<T, U> Into<U> for T where
        U: From<T>,     [src]
    impl<T> Spanned for T where
        T: Spanned + ?Sized,     [src]
    impl<T> ToOwned for T where
        T: Clone,     [src]
    type Owned = T
    The resulting type after obtaining ownership.
    
-
    impl<T> ToOwned for T where
        T: Clone,     [src]
    type Owned = T
    The resulting type after obtaining ownership.
    
+
    impl<T, U> TryFrom<U> for T where
        U: Into<T>,     [src]
    type Error = Infallible
    The type returned in the event of a conversion error.
    
-
    impl<T, U> TryInto<U> for T where
        U: TryFrom<T>,     [src]
    type Error = <U as TryFrom<T>>::Error
    The type returned in the event of a conversion error.
    
-
    
\ No newline at end of file
+

    impl<T, U> TryFrom<U> for T where
        U: Into<T>,     [src]

    type Error = Infallible

    The type returned in the event of a conversion error.

    +

    impl<T, U> TryInto<U> for T where
        U: TryFrom<T>,     [src]

    type Error = <U as TryFrom<T>>::Error

    The type returned in the event of a conversion error.

    +
    + \ No newline at end of file diff --git a/syn/token/struct.Star.html b/syn/token/struct.Star.html index ec0c0f1..06bd02e 100644 --- a/syn/token/struct.Star.html +++ b/syn/token/struct.Star.html @@ -1,40 +1,41 @@ -syn::token::Star - Rust +syn::token::Star - Rust -

    [−][src]Struct syn::token::Star

    #[repr(C)]pub struct Star {
+
    Struct syn::token::Star[−][src]
    #[repr(C)]pub struct Star {
     pub spans: [Span; 1],
 }
    *
    
-
    Don't try to remember the name of this type — use the
+
    Don’t try to remember the name of this type — use the
 Token! macro instead.
    
 
    
                        Fields
    spans: [Span; 1]
    Trait Implementations
    impl Clone for Star[src]
    impl Copy for Star[src]
    impl Debug for Star[src]
    impl Default for Star[src]
    impl Default for Star[src]
    impl Deref for Star[src]
    type Target = WithSpan
    The resulting type after dereferencing.
    
 
    impl DerefMut for Star[src]
    impl Eq for Star[src]
    impl Hash for Star[src]
    impl Parse for Star[src]
    impl PartialEq<Star> for Star[src]
    impl ToTokens for Star[src]
    impl Token for Star[src]
    Auto Trait Implementations
    Blanket Implementations
    impl<T> Any for T where
        T: 'static + ?Sized,     [src]
    impl<T> Borrow<T> for T where
        T: ?Sized,     [src]
    impl<T> BorrowMut<T> for T where
        T: ?Sized,     [src]
    impl<T> From<T> for T[src]
    impl<T, U> Into<U> for T where
        U: From<T>,     [src]
    impl Token for Star[src]
    Auto Trait Implementations
    impl RefUnwindSafe for Star
    impl !Send for Star
    impl !Sync for Star
    impl Unpin for Star
    impl UnwindSafe for Star
    Blanket Implementations
    impl<T> Any for T where
        T: 'static + ?Sized,     [src]
    impl<T> Borrow<T> for T where
        T: ?Sized,     [src]
    impl<T> BorrowMut<T> for T where
        T: ?Sized,     [src]
    impl<T> From<T> for T[src]
    impl<T, U> Into<U> for T where
        U: From<T>,     [src]
    impl<T> Spanned for T where
        T: Spanned + ?Sized,     [src]
    impl<T> ToOwned for T where
        T: Clone,     [src]
    type Owned = T
    The resulting type after obtaining ownership.
    
-
    impl<T> ToOwned for T where
        T: Clone,     [src]
    type Owned = T
    The resulting type after obtaining ownership.
    
+
    impl<T, U> TryFrom<U> for T where
        U: Into<T>,     [src]
    type Error = Infallible
    The type returned in the event of a conversion error.
    
-
    impl<T, U> TryInto<U> for T where
        U: TryFrom<T>,     [src]
    type Error = <U as TryFrom<T>>::Error
    The type returned in the event of a conversion error.
    
-
    
\ No newline at end of file
+

    impl<T, U> TryFrom<U> for T where
        U: Into<T>,     [src]

    type Error = Infallible

    The type returned in the event of a conversion error.

    +

    impl<T, U> TryInto<U> for T where
        U: TryFrom<T>,     [src]

    type Error = <U as TryFrom<T>>::Error

    The type returned in the event of a conversion error.

    +
    + \ No newline at end of file diff --git a/syn/token/struct.Static.html b/syn/token/struct.Static.html index 1530a00..7afa449 100644 --- a/syn/token/struct.Static.html +++ b/syn/token/struct.Static.html @@ -1,37 +1,38 @@ -syn::token::Static - Rust +syn::token::Static - Rust -

    [−][src]Struct syn::token::Static

    pub struct Static {
+
    Struct syn::token::Static[−][src]
    pub struct Static {
     pub span: Span,
 }
    static
    
-
    Don't try to remember the name of this type — use the
+
    Don’t try to remember the name of this type — use the
 Token! macro instead.
    
 
    
                        Fields
    span: Span
    Trait Implementations
    impl Clone for Static[src]
    impl Copy for Static[src]
    impl Debug for Static[src]
    impl Default for Static[src]
    impl Default for Static[src]
    impl Eq for Static[src]
    impl Hash for Static[src]
    impl Parse for Static[src]
    impl PartialEq<Static> for Static[src]
    impl ToTokens for Static[src]
    impl Token for Static[src]
    Auto Trait Implementations
    Blanket Implementations
    impl<T> Any for T where
        T: 'static + ?Sized,     [src]
    impl<T> Borrow<T> for T where
        T: ?Sized,     [src]
    impl<T> BorrowMut<T> for T where
        T: ?Sized,     [src]
    impl<T> From<T> for T[src]
    impl<T, U> Into<U> for T where
        U: From<T>,     [src]
    impl Token for Static[src]
    Auto Trait Implementations
    impl RefUnwindSafe for Static
    impl !Send for Static
    impl !Sync for Static
    impl Unpin for Static
    impl UnwindSafe for Static
    Blanket Implementations
    impl<T> Any for T where
        T: 'static + ?Sized,     [src]
    impl<T> Borrow<T> for T where
        T: ?Sized,     [src]
    impl<T> BorrowMut<T> for T where
        T: ?Sized,     [src]
    impl<T> From<T> for T[src]
    impl<T, U> Into<U> for T where
        U: From<T>,     [src]
    impl<T> Spanned for T where
        T: Spanned + ?Sized,     [src]
    impl<T> ToOwned for T where
        T: Clone,     [src]
    type Owned = T
    The resulting type after obtaining ownership.
    
-
    impl<T> ToOwned for T where
        T: Clone,     [src]
    type Owned = T
    The resulting type after obtaining ownership.
    
+
    impl<T, U> TryFrom<U> for T where
        U: Into<T>,     [src]
    type Error = Infallible
    The type returned in the event of a conversion error.
    
-
    impl<T, U> TryInto<U> for T where
        U: TryFrom<T>,     [src]
    type Error = <U as TryFrom<T>>::Error
    The type returned in the event of a conversion error.
    
-
    
\ No newline at end of file
+

    impl<T, U> TryFrom<U> for T where
        U: Into<T>,     [src]

    type Error = Infallible

    The type returned in the event of a conversion error.

    +

    impl<T, U> TryInto<U> for T where
        U: TryFrom<T>,     [src]

    type Error = <U as TryFrom<T>>::Error

    The type returned in the event of a conversion error.

    +
    + \ No newline at end of file diff --git a/syn/token/struct.Struct.html b/syn/token/struct.Struct.html index 74a12f6..42cc29b 100644 --- a/syn/token/struct.Struct.html +++ b/syn/token/struct.Struct.html @@ -1,37 +1,38 @@ -syn::token::Struct - Rust +syn::token::Struct - Rust -

    [−][src]Struct syn::token::Struct

    pub struct Struct {
+
    Struct syn::token::Struct[−][src]
    pub struct Struct {
     pub span: Span,
 }
    struct
    
-
    Don't try to remember the name of this type — use the
+
    Don’t try to remember the name of this type — use the
 Token! macro instead.
    
 
    
                        Fields
    span: Span
    Trait Implementations
    impl Clone for Struct[src]
    impl Copy for Struct[src]
    impl Debug for Struct[src]
    impl Default for Struct[src]
    impl Default for Struct[src]
    impl Eq for Struct[src]
    impl Hash for Struct[src]
    impl Parse for Struct[src]
    impl PartialEq<Struct> for Struct[src]
    impl ToTokens for Struct[src]
    impl Token for Struct[src]
    Auto Trait Implementations
    Blanket Implementations
    impl<T> Any for T where
        T: 'static + ?Sized,     [src]
    impl<T> Borrow<T> for T where
        T: ?Sized,     [src]
    impl<T> BorrowMut<T> for T where
        T: ?Sized,     [src]
    impl<T> From<T> for T[src]
    impl<T, U> Into<U> for T where
        U: From<T>,     [src]
    impl Token for Struct[src]
    Auto Trait Implementations
    impl RefUnwindSafe for Struct
    impl !Send for Struct
    impl !Sync for Struct
    impl Unpin for Struct
    impl UnwindSafe for Struct
    Blanket Implementations
    impl<T> Any for T where
        T: 'static + ?Sized,     [src]
    impl<T> Borrow<T> for T where
        T: ?Sized,     [src]
    impl<T> BorrowMut<T> for T where
        T: ?Sized,     [src]
    impl<T> From<T> for T[src]
    impl<T, U> Into<U> for T where
        U: From<T>,     [src]
    impl<T> Spanned for T where
        T: Spanned + ?Sized,     [src]
    impl<T> ToOwned for T where
        T: Clone,     [src]
    type Owned = T
    The resulting type after obtaining ownership.
    
-
    impl<T> ToOwned for T where
        T: Clone,     [src]
    type Owned = T
    The resulting type after obtaining ownership.
    
+
    impl<T, U> TryFrom<U> for T where
        U: Into<T>,     [src]
    type Error = Infallible
    The type returned in the event of a conversion error.
    
-
    impl<T, U> TryInto<U> for T where
        U: TryFrom<T>,     [src]
    type Error = <U as TryFrom<T>>::Error
    The type returned in the event of a conversion error.
    
-
    
\ No newline at end of file
+

    impl<T, U> TryFrom<U> for T where
        U: Into<T>,     [src]

    type Error = Infallible

    The type returned in the event of a conversion error.

    +

    impl<T, U> TryInto<U> for T where
        U: TryFrom<T>,     [src]

    type Error = <U as TryFrom<T>>::Error

    The type returned in the event of a conversion error.

    +
    + \ No newline at end of file diff --git a/syn/token/struct.Sub.html b/syn/token/struct.Sub.html index b59cee2..617d2d6 100644 --- a/syn/token/struct.Sub.html +++ b/syn/token/struct.Sub.html @@ -1,40 +1,41 @@ -syn::token::Sub - Rust +syn::token::Sub - Rust -

    [−][src]Struct syn::token::Sub

    #[repr(C)]pub struct Sub {
+
    Struct syn::token::Sub[−][src]
    #[repr(C)]pub struct Sub {
     pub spans: [Span; 1],
 }
    -
    
-
    Don't try to remember the name of this type — use the
+
    Don’t try to remember the name of this type — use the
 Token! macro instead.
    
 
    
                        Fields
    spans: [Span; 1]
    Trait Implementations
    impl Clone for Sub[src]
    impl Copy for Sub[src]
    impl Debug for Sub[src]
    impl Default for Sub[src]
    impl Default for Sub[src]
    impl Deref for Sub[src]
    type Target = WithSpan
    The resulting type after dereferencing.
    
 
    impl DerefMut for Sub[src]
    impl Eq for Sub[src]
    impl Hash for Sub[src]
    impl Parse for Sub[src]
    impl PartialEq<Sub> for Sub[src]
    impl ToTokens for Sub[src]
    impl Token for Sub[src]
    Auto Trait Implementations
    impl RefUnwindSafe for Sub[src]
    impl !Send for Sub[src]
    impl !Sync for Sub[src]
    impl Unpin for Sub[src]
    impl UnwindSafe for Sub[src]
    Blanket Implementations
    impl<T> Any for T where
        T: 'static + ?Sized,     [src]
    impl<T> Borrow<T> for T where
        T: ?Sized,     [src]
    impl<T> BorrowMut<T> for T where
        T: ?Sized,     [src]
    impl<T> From<T> for T[src]
    impl<T, U> Into<U> for T where
        U: From<T>,     [src]
    impl Token for Sub[src]
    Auto Trait Implementations
    impl RefUnwindSafe for Sub
    impl !Send for Sub
    impl !Sync for Sub
    impl Unpin for Sub
    impl UnwindSafe for Sub
    Blanket Implementations
    impl<T> Any for T where
        T: 'static + ?Sized,     [src]
    impl<T> Borrow<T> for T where
        T: ?Sized,     [src]
    impl<T> BorrowMut<T> for T where
        T: ?Sized,     [src]
    impl<T> From<T> for T[src]
    impl<T, U> Into<U> for T where
        U: From<T>,     [src]
    impl<T> Spanned for T where
        T: Spanned + ?Sized,     [src]
    impl<T> ToOwned for T where
        T: Clone,     [src]
    type Owned = T
    The resulting type after obtaining ownership.
    
-
    impl<T> ToOwned for T where
        T: Clone,     [src]
    type Owned = T
    The resulting type after obtaining ownership.
    
+
    impl<T, U> TryFrom<U> for T where
        U: Into<T>,     [src]
    type Error = Infallible
    The type returned in the event of a conversion error.
    
-
    impl<T, U> TryInto<U> for T where
        U: TryFrom<T>,     [src]
    type Error = <U as TryFrom<T>>::Error
    The type returned in the event of a conversion error.
    
-
    
\ No newline at end of file
+

    impl<T, U> TryFrom<U> for T where
        U: Into<T>,     [src]

    type Error = Infallible

    The type returned in the event of a conversion error.

    +

    impl<T, U> TryInto<U> for T where
        U: TryFrom<T>,     [src]

    type Error = <U as TryFrom<T>>::Error

    The type returned in the event of a conversion error.

    +
    + \ No newline at end of file diff --git a/syn/token/struct.SubEq.html b/syn/token/struct.SubEq.html index d97b17c..97cbe06 100644 --- a/syn/token/struct.SubEq.html +++ b/syn/token/struct.SubEq.html @@ -1,37 +1,38 @@ -syn::token::SubEq - Rust +syn::token::SubEq - Rust -

    [−][src]Struct syn::token::SubEq

    #[repr(C)]pub struct SubEq {
+
    Struct syn::token::SubEq[−][src]
    #[repr(C)]pub struct SubEq {
     pub spans: [Span; 2],
 }
    -=
    
-
    Don't try to remember the name of this type — use the
+
    Don’t try to remember the name of this type — use the
 Token! macro instead.
    
 
    
                        Fields
    spans: [Span; 2]
    Trait Implementations
    impl Clone for SubEq[src]
    impl Copy for SubEq[src]
    impl Debug for SubEq[src]
    impl Default for SubEq[src]
    impl Default for SubEq[src]
    impl Eq for SubEq[src]
    impl Hash for SubEq[src]
    impl Parse for SubEq[src]
    impl PartialEq<SubEq> for SubEq[src]
    impl ToTokens for SubEq[src]
    impl Token for SubEq[src]
    Auto Trait Implementations
    Blanket Implementations
    impl<T> Any for T where
        T: 'static + ?Sized,     [src]
    impl<T> Borrow<T> for T where
        T: ?Sized,     [src]
    impl<T> BorrowMut<T> for T where
        T: ?Sized,     [src]
    impl<T> From<T> for T[src]
    impl<T, U> Into<U> for T where
        U: From<T>,     [src]
    impl Token for SubEq[src]
    Auto Trait Implementations
    impl RefUnwindSafe for SubEq
    impl !Send for SubEq
    impl !Sync for SubEq
    impl Unpin for SubEq
    impl UnwindSafe for SubEq
    Blanket Implementations
    impl<T> Any for T where
        T: 'static + ?Sized,     [src]
    impl<T> Borrow<T> for T where
        T: ?Sized,     [src]
    impl<T> BorrowMut<T> for T where
        T: ?Sized,     [src]
    impl<T> From<T> for T[src]
    impl<T, U> Into<U> for T where
        U: From<T>,     [src]
    impl<T> Spanned for T where
        T: Spanned + ?Sized,     [src]
    impl<T> ToOwned for T where
        T: Clone,     [src]
    type Owned = T
    The resulting type after obtaining ownership.
    
-
    impl<T> ToOwned for T where
        T: Clone,     [src]
    type Owned = T
    The resulting type after obtaining ownership.
    
+
    impl<T, U> TryFrom<U> for T where
        U: Into<T>,     [src]
    type Error = Infallible
    The type returned in the event of a conversion error.
    
-
    impl<T, U> TryInto<U> for T where
        U: TryFrom<T>,     [src]
    type Error = <U as TryFrom<T>>::Error
    The type returned in the event of a conversion error.
    
-
    
\ No newline at end of file
+

    impl<T, U> TryFrom<U> for T where
        U: Into<T>,     [src]

    type Error = Infallible

    The type returned in the event of a conversion error.

    +

    impl<T, U> TryInto<U> for T where
        U: TryFrom<T>,     [src]

    type Error = <U as TryFrom<T>>::Error

    The type returned in the event of a conversion error.

    +
    + \ No newline at end of file diff --git a/syn/token/struct.Super.html b/syn/token/struct.Super.html index 5d1a837..314aabc 100644 --- a/syn/token/struct.Super.html +++ b/syn/token/struct.Super.html @@ -1,38 +1,39 @@ -syn::token::Super - Rust +syn::token::Super - Rust -

    [−][src]Struct syn::token::Super

    pub struct Super {
+
    Struct syn::token::Super[−][src]
    pub struct Super {
     pub span: Span,
 }
    super
    
-
    Don't try to remember the name of this type — use the
+
    Don’t try to remember the name of this type — use the
 Token! macro instead.
    
 
    
                        Fields
    span: Span
    Trait Implementations
    impl Clone for Super[src]
    impl Copy for Super[src]
    impl Debug for Super[src]
    impl Default for Super[src]
    impl Default for Super[src]
    impl Eq for Super[src]
    impl From<Super> for Ident[src]
    impl Hash for Super[src]
    impl Parse for Super[src]
    impl PartialEq<Super> for Super[src]
    impl ToTokens for Super[src]
    impl Token for Super[src]
    Auto Trait Implementations
    Blanket Implementations
    impl<T> Any for T where
        T: 'static + ?Sized,     [src]
    impl<T> Borrow<T> for T where
        T: ?Sized,     [src]
    impl<T> BorrowMut<T> for T where
        T: ?Sized,     [src]
    impl<T> From<T> for T[src]
    impl<T, U> Into<U> for T where
        U: From<T>,     [src]
    impl Token for Super[src]
    Auto Trait Implementations
    impl RefUnwindSafe for Super
    impl !Send for Super
    impl !Sync for Super
    impl Unpin for Super
    impl UnwindSafe for Super
    Blanket Implementations
    impl<T> Any for T where
        T: 'static + ?Sized,     [src]
    impl<T> Borrow<T> for T where
        T: ?Sized,     [src]
    impl<T> BorrowMut<T> for T where
        T: ?Sized,     [src]
    impl<T> From<T> for T[src]
    impl<T, U> Into<U> for T where
        U: From<T>,     [src]
    impl<T> Spanned for T where
        T: Spanned + ?Sized,     [src]
    impl<T> ToOwned for T where
        T: Clone,     [src]
    type Owned = T
    The resulting type after obtaining ownership.
    
-
    impl<T> ToOwned for T where
        T: Clone,     [src]
    type Owned = T
    The resulting type after obtaining ownership.
    
+
    impl<T, U> TryFrom<U> for T where
        U: Into<T>,     [src]
    type Error = Infallible
    The type returned in the event of a conversion error.
    
-
    impl<T, U> TryInto<U> for T where
        U: TryFrom<T>,     [src]
    type Error = <U as TryFrom<T>>::Error
    The type returned in the event of a conversion error.
    
-
    
\ No newline at end of file
+

    impl<T, U> TryFrom<U> for T where
        U: Into<T>,     [src]

    type Error = Infallible

    The type returned in the event of a conversion error.

    +

    impl<T, U> TryInto<U> for T where
        U: TryFrom<T>,     [src]

    type Error = <U as TryFrom<T>>::Error

    The type returned in the event of a conversion error.

    +
    + \ No newline at end of file diff --git a/syn/token/struct.Tilde.html b/syn/token/struct.Tilde.html index 36dfd9b..995a6d7 100644 --- a/syn/token/struct.Tilde.html +++ b/syn/token/struct.Tilde.html @@ -1,40 +1,41 @@ -syn::token::Tilde - Rust +syn::token::Tilde - Rust -

    [−][src]Struct syn::token::Tilde

    #[repr(C)]pub struct Tilde {
+
    Struct syn::token::Tilde[−][src]
    #[repr(C)]pub struct Tilde {
     pub spans: [Span; 1],
 }
    ~
    
-
    Don't try to remember the name of this type — use the
+
    Don’t try to remember the name of this type — use the
 Token! macro instead.
    
 
    
                        Fields
    spans: [Span; 1]
    Trait Implementations
    impl Clone for Tilde[src]
    impl Copy for Tilde[src]
    impl Debug for Tilde[src]
    impl Default for Tilde[src]
    impl Default for Tilde[src]
    impl Deref for Tilde[src]
    type Target = WithSpan
    The resulting type after dereferencing.
    
 
    impl DerefMut for Tilde[src]
    impl Eq for Tilde[src]
    impl Hash for Tilde[src]
    impl Parse for Tilde[src]
    impl PartialEq<Tilde> for Tilde[src]
    impl ToTokens for Tilde[src]
    impl Token for Tilde[src]
    Auto Trait Implementations
    Blanket Implementations
    impl<T> Any for T where
        T: 'static + ?Sized,     [src]
    impl<T> Borrow<T> for T where
        T: ?Sized,     [src]
    impl<T> BorrowMut<T> for T where
        T: ?Sized,     [src]
    impl<T> From<T> for T[src]
    impl<T, U> Into<U> for T where
        U: From<T>,     [src]
    impl Token for Tilde[src]
    Auto Trait Implementations
    impl RefUnwindSafe for Tilde
    impl !Send for Tilde
    impl !Sync for Tilde
    impl Unpin for Tilde
    impl UnwindSafe for Tilde
    Blanket Implementations
    impl<T> Any for T where
        T: 'static + ?Sized,     [src]
    impl<T> Borrow<T> for T where
        T: ?Sized,     [src]
    impl<T> BorrowMut<T> for T where
        T: ?Sized,     [src]
    impl<T> From<T> for T[src]
    impl<T, U> Into<U> for T where
        U: From<T>,     [src]
    impl<T> Spanned for T where
        T: Spanned + ?Sized,     [src]
    impl<T> ToOwned for T where
        T: Clone,     [src]
    type Owned = T
    The resulting type after obtaining ownership.
    
-
    impl<T> ToOwned for T where
        T: Clone,     [src]
    type Owned = T
    The resulting type after obtaining ownership.
    
+
    impl<T, U> TryFrom<U> for T where
        U: Into<T>,     [src]
    type Error = Infallible
    The type returned in the event of a conversion error.
    
-
    impl<T, U> TryInto<U> for T where
        U: TryFrom<T>,     [src]
    type Error = <U as TryFrom<T>>::Error
    The type returned in the event of a conversion error.
    
-
    
\ No newline at end of file
+

    impl<T, U> TryFrom<U> for T where
        U: Into<T>,     [src]

    type Error = Infallible

    The type returned in the event of a conversion error.

    +

    impl<T, U> TryInto<U> for T where
        U: TryFrom<T>,     [src]

    type Error = <U as TryFrom<T>>::Error

    The type returned in the event of a conversion error.

    +
    + \ No newline at end of file diff --git a/syn/token/struct.Trait.html b/syn/token/struct.Trait.html index a158fff..6d56b7b 100644 --- a/syn/token/struct.Trait.html +++ b/syn/token/struct.Trait.html @@ -1,37 +1,38 @@ -syn::token::Trait - Rust +syn::token::Trait - Rust -

    [−][src]Struct syn::token::Trait

    pub struct Trait {
+
    Struct syn::token::Trait[−][src]
    pub struct Trait {
     pub span: Span,
 }
    trait
    
-
    Don't try to remember the name of this type — use the
+
    Don’t try to remember the name of this type — use the
 Token! macro instead.
    
 
    
                        Fields
    span: Span
    Trait Implementations
    impl Clone for Trait[src]
    impl Copy for Trait[src]
    impl Debug for Trait[src]
    impl Default for Trait[src]
    impl Default for Trait[src]
    impl Eq for Trait[src]
    impl Hash for Trait[src]
    impl Parse for Trait[src]
    impl PartialEq<Trait> for Trait[src]
    impl ToTokens for Trait[src]
    impl Token for Trait[src]
    Auto Trait Implementations
    Blanket Implementations
    impl<T> Any for T where
        T: 'static + ?Sized,     [src]
    impl<T> Borrow<T> for T where
        T: ?Sized,     [src]
    impl<T> BorrowMut<T> for T where
        T: ?Sized,     [src]
    impl<T> From<T> for T[src]
    impl<T, U> Into<U> for T where
        U: From<T>,     [src]
    impl Token for Trait[src]
    Auto Trait Implementations
    impl RefUnwindSafe for Trait
    impl !Send for Trait
    impl !Sync for Trait
    impl Unpin for Trait
    impl UnwindSafe for Trait
    Blanket Implementations
    impl<T> Any for T where
        T: 'static + ?Sized,     [src]
    impl<T> Borrow<T> for T where
        T: ?Sized,     [src]
    impl<T> BorrowMut<T> for T where
        T: ?Sized,     [src]
    impl<T> From<T> for T[src]
    impl<T, U> Into<U> for T where
        U: From<T>,     [src]
    impl<T> Spanned for T where
        T: Spanned + ?Sized,     [src]
    impl<T> ToOwned for T where
        T: Clone,     [src]
    type Owned = T
    The resulting type after obtaining ownership.
    
-
    impl<T> ToOwned for T where
        T: Clone,     [src]
    type Owned = T
    The resulting type after obtaining ownership.
    
+
    impl<T, U> TryFrom<U> for T where
        U: Into<T>,     [src]
    type Error = Infallible
    The type returned in the event of a conversion error.
    
-
    impl<T, U> TryInto<U> for T where
        U: TryFrom<T>,     [src]
    type Error = <U as TryFrom<T>>::Error
    The type returned in the event of a conversion error.
    
-
    
\ No newline at end of file
+

    impl<T, U> TryFrom<U> for T where
        U: Into<T>,     [src]

    type Error = Infallible

    The type returned in the event of a conversion error.

    +

    impl<T, U> TryInto<U> for T where
        U: TryFrom<T>,     [src]

    type Error = <U as TryFrom<T>>::Error

    The type returned in the event of a conversion error.

    +
    + \ No newline at end of file diff --git a/syn/token/struct.Try.html b/syn/token/struct.Try.html index 9921b33..f4b7566 100644 --- a/syn/token/struct.Try.html +++ b/syn/token/struct.Try.html @@ -1,37 +1,38 @@ -syn::token::Try - Rust +syn::token::Try - Rust -

    [−][src]Struct syn::token::Try

    pub struct Try {
+
    Struct syn::token::Try[−][src]
    pub struct Try {
     pub span: Span,
 }
    try
    
-
    Don't try to remember the name of this type — use the
+
    Don’t try to remember the name of this type — use the
 Token! macro instead.
    
 
    
                        Fields
    span: Span
    Trait Implementations
    impl Clone for Try[src]
    impl Copy for Try[src]
    impl Debug for Try[src]
    impl Default for Try[src]
    impl Default for Try[src]
    impl Eq for Try[src]
    impl Hash for Try[src]
    impl Parse for Try[src]
    impl PartialEq<Try> for Try[src]
    impl ToTokens for Try[src]
    impl Token for Try[src]
    Auto Trait Implementations
    impl RefUnwindSafe for Try[src]
    impl !Send for Try[src]
    impl !Sync for Try[src]
    impl Unpin for Try[src]
    impl UnwindSafe for Try[src]
    Blanket Implementations
    impl<T> Any for T where
        T: 'static + ?Sized,     [src]
    impl<T> Borrow<T> for T where
        T: ?Sized,     [src]
    impl<T> BorrowMut<T> for T where
        T: ?Sized,     [src]
    impl<T> From<T> for T[src]
    impl<T, U> Into<U> for T where
        U: From<T>,     [src]
    impl Token for Try[src]
    Auto Trait Implementations
    impl RefUnwindSafe for Try
    impl !Send for Try
    impl !Sync for Try
    impl Unpin for Try
    impl UnwindSafe for Try
    Blanket Implementations
    impl<T> Any for T where
        T: 'static + ?Sized,     [src]
    impl<T> Borrow<T> for T where
        T: ?Sized,     [src]
    impl<T> BorrowMut<T> for T where
        T: ?Sized,     [src]
    impl<T> From<T> for T[src]
    impl<T, U> Into<U> for T where
        U: From<T>,     [src]
    impl<T> Spanned for T where
        T: Spanned + ?Sized,     [src]
    impl<T> ToOwned for T where
        T: Clone,     [src]
    type Owned = T
    The resulting type after obtaining ownership.
    
-
    impl<T> ToOwned for T where
        T: Clone,     [src]
    type Owned = T
    The resulting type after obtaining ownership.
    
+
    impl<T, U> TryFrom<U> for T where
        U: Into<T>,     [src]
    type Error = Infallible
    The type returned in the event of a conversion error.
    
-
    impl<T, U> TryInto<U> for T where
        U: TryFrom<T>,     [src]
    type Error = <U as TryFrom<T>>::Error
    The type returned in the event of a conversion error.
    
-
    
\ No newline at end of file
+

    impl<T, U> TryFrom<U> for T where
        U: Into<T>,     [src]

    type Error = Infallible

    The type returned in the event of a conversion error.

    +

    impl<T, U> TryInto<U> for T where
        U: TryFrom<T>,     [src]

    type Error = <U as TryFrom<T>>::Error

    The type returned in the event of a conversion error.

    +
    + \ No newline at end of file diff --git a/syn/token/struct.Type.html b/syn/token/struct.Type.html index 86ff58d..f2e6ddf 100644 --- a/syn/token/struct.Type.html +++ b/syn/token/struct.Type.html @@ -1,37 +1,38 @@ -syn::token::Type - Rust +syn::token::Type - Rust -

    [−][src]Struct syn::token::Type

    pub struct Type {
+
    Struct syn::token::Type[−][src]
    pub struct Type {
     pub span: Span,
 }
    type
    
-
    Don't try to remember the name of this type — use the
+
    Don’t try to remember the name of this type — use the
 Token! macro instead.
    
 
    
                        Fields
    span: Span
    Trait Implementations
    impl Clone for Type[src]
    impl Copy for Type[src]
    impl Debug for Type[src]
    impl Default for Type[src]
    impl Default for Type[src]
    impl Eq for Type[src]
    impl Hash for Type[src]
    impl Parse for Type[src]
    impl PartialEq<Type> for Type[src]
    impl ToTokens for Type[src]
    impl Token for Type[src]
    Auto Trait Implementations
    Blanket Implementations
    impl<T> Any for T where
        T: 'static + ?Sized,     [src]
    impl<T> Borrow<T> for T where
        T: ?Sized,     [src]
    impl<T> BorrowMut<T> for T where
        T: ?Sized,     [src]
    impl<T> From<T> for T[src]
    impl<T, U> Into<U> for T where
        U: From<T>,     [src]
    impl Token for Type[src]
    Auto Trait Implementations
    impl RefUnwindSafe for Type
    impl !Send for Type
    impl !Sync for Type
    impl Unpin for Type
    impl UnwindSafe for Type
    Blanket Implementations
    impl<T> Any for T where
        T: 'static + ?Sized,     [src]
    impl<T> Borrow<T> for T where
        T: ?Sized,     [src]
    impl<T> BorrowMut<T> for T where
        T: ?Sized,     [src]
    impl<T> From<T> for T[src]
    impl<T, U> Into<U> for T where
        U: From<T>,     [src]
    impl<T> Spanned for T where
        T: Spanned + ?Sized,     [src]
    impl<T> ToOwned for T where
        T: Clone,     [src]
    type Owned = T
    The resulting type after obtaining ownership.
    
-
    impl<T> ToOwned for T where
        T: Clone,     [src]
    type Owned = T
    The resulting type after obtaining ownership.
    
+
    impl<T, U> TryFrom<U> for T where
        U: Into<T>,     [src]
    type Error = Infallible
    The type returned in the event of a conversion error.
    
-
    impl<T, U> TryInto<U> for T where
        U: TryFrom<T>,     [src]
    type Error = <U as TryFrom<T>>::Error
    The type returned in the event of a conversion error.
    
-
    
\ No newline at end of file
+

    impl<T, U> TryFrom<U> for T where
        U: Into<T>,     [src]

    type Error = Infallible

    The type returned in the event of a conversion error.

    +

    impl<T, U> TryInto<U> for T where
        U: TryFrom<T>,     [src]

    type Error = <U as TryFrom<T>>::Error

    The type returned in the event of a conversion error.

    +
    + \ No newline at end of file diff --git a/syn/token/struct.Typeof.html b/syn/token/struct.Typeof.html index bbdf240..eef847c 100644 --- a/syn/token/struct.Typeof.html +++ b/syn/token/struct.Typeof.html @@ -1,37 +1,38 @@ -syn::token::Typeof - Rust +syn::token::Typeof - Rust -

    [−][src]Struct syn::token::Typeof

    pub struct Typeof {
+
    Struct syn::token::Typeof[−][src]
    pub struct Typeof {
     pub span: Span,
 }
    typeof
    
-
    Don't try to remember the name of this type — use the
+
    Don’t try to remember the name of this type — use the
 Token! macro instead.
    
 
    
                        Fields
    span: Span
    Trait Implementations
    impl Clone for Typeof[src]
    impl Copy for Typeof[src]
    impl Debug for Typeof[src]
    impl Default for Typeof[src]
    impl Default for Typeof[src]
    impl Eq for Typeof[src]
    impl Hash for Typeof[src]
    impl Parse for Typeof[src]
    impl PartialEq<Typeof> for Typeof[src]
    impl ToTokens for Typeof[src]
    impl Token for Typeof[src]
    Auto Trait Implementations
    Blanket Implementations
    impl<T> Any for T where
        T: 'static + ?Sized,     [src]
    impl<T> Borrow<T> for T where
        T: ?Sized,     [src]
    impl<T> BorrowMut<T> for T where
        T: ?Sized,     [src]
    impl<T> From<T> for T[src]
    impl<T, U> Into<U> for T where
        U: From<T>,     [src]
    impl Token for Typeof[src]
    Auto Trait Implementations
    impl RefUnwindSafe for Typeof
    impl !Send for Typeof
    impl !Sync for Typeof
    impl Unpin for Typeof
    impl UnwindSafe for Typeof
    Blanket Implementations
    impl<T> Any for T where
        T: 'static + ?Sized,     [src]
    impl<T> Borrow<T> for T where
        T: ?Sized,     [src]
    impl<T> BorrowMut<T> for T where
        T: ?Sized,     [src]
    impl<T> From<T> for T[src]
    impl<T, U> Into<U> for T where
        U: From<T>,     [src]
    impl<T> Spanned for T where
        T: Spanned + ?Sized,     [src]
    impl<T> ToOwned for T where
        T: Clone,     [src]
    type Owned = T
    The resulting type after obtaining ownership.
    
-
    impl<T> ToOwned for T where
        T: Clone,     [src]
    type Owned = T
    The resulting type after obtaining ownership.
    
+
    impl<T, U> TryFrom<U> for T where
        U: Into<T>,     [src]
    type Error = Infallible
    The type returned in the event of a conversion error.
    
-
    impl<T, U> TryInto<U> for T where
        U: TryFrom<T>,     [src]
    type Error = <U as TryFrom<T>>::Error
    The type returned in the event of a conversion error.
    
-
    
\ No newline at end of file
+

    impl<T, U> TryFrom<U> for T where
        U: Into<T>,     [src]

    type Error = Infallible

    The type returned in the event of a conversion error.

    +

    impl<T, U> TryInto<U> for T where
        U: TryFrom<T>,     [src]

    type Error = <U as TryFrom<T>>::Error

    The type returned in the event of a conversion error.

    +
    + \ No newline at end of file diff --git a/syn/token/struct.Underscore.html b/syn/token/struct.Underscore.html index a6ee0b7..fda6d1b 100644 --- a/syn/token/struct.Underscore.html +++ b/syn/token/struct.Underscore.html @@ -1,41 +1,42 @@ -syn::token::Underscore - Rust +syn::token::Underscore - Rust -

    [−][src]Struct syn::token::Underscore

    #[repr(C)]pub struct Underscore {
+
    Struct syn::token::Underscore[−][src]
    #[repr(C)]pub struct Underscore {
     pub spans: [Span; 1],
 }
    _
    
-
    Don't try to remember the name of this type — use the
+
    Don’t try to remember the name of this type — use the
 Token! macro instead.
    
 
    
                        Fields
    spans: [Span; 1]
    Trait Implementations
    impl Clone for Underscore[src]
    impl Copy for Underscore[src]
    impl Debug for Underscore[src]
    impl Default for Underscore[src]
    impl Default for Underscore[src]
    impl Deref for Underscore[src]
    type Target = WithSpan
    The resulting type after dereferencing.
    
 
    impl DerefMut for Underscore[src]
    impl Eq for Underscore[src]
    impl From<Underscore> for Ident[src]
    impl Hash for Underscore[src]
    impl Parse for Underscore[src]
    impl PartialEq<Underscore> for Underscore[src]
    impl ToTokens for Underscore[src]
    impl Token for Underscore[src]
    Auto Trait Implementations
    Blanket Implementations
    impl<T> Any for T where
        T: 'static + ?Sized,     [src]
    impl<T> Borrow<T> for T where
        T: ?Sized,     [src]
    impl<T> BorrowMut<T> for T where
        T: ?Sized,     [src]
    impl<T> From<T> for T[src]
    impl<T, U> Into<U> for T where
        U: From<T>,     [src]
    impl Token for Underscore[src]
    Auto Trait Implementations
    Blanket Implementations
    impl<T> Any for T where
        T: 'static + ?Sized,     [src]
    impl<T> Borrow<T> for T where
        T: ?Sized,     [src]
    impl<T> BorrowMut<T> for T where
        T: ?Sized,     [src]
    impl<T> From<T> for T[src]
    impl<T, U> Into<U> for T where
        U: From<T>,     [src]
    impl<T> Spanned for T where
        T: Spanned + ?Sized,     [src]
    impl<T> ToOwned for T where
        T: Clone,     [src]
    type Owned = T
    The resulting type after obtaining ownership.
    
-
    impl<T> ToOwned for T where
        T: Clone,     [src]
    type Owned = T
    The resulting type after obtaining ownership.
    
+
    impl<T, U> TryFrom<U> for T where
        U: Into<T>,     [src]
    type Error = Infallible
    The type returned in the event of a conversion error.
    
-
    impl<T, U> TryInto<U> for T where
        U: TryFrom<T>,     [src]
    type Error = <U as TryFrom<T>>::Error
    The type returned in the event of a conversion error.
    
-
    
\ No newline at end of file
+

    impl<T, U> TryFrom<U> for T where
        U: Into<T>,     [src]

    type Error = Infallible

    The type returned in the event of a conversion error.

    +

    impl<T, U> TryInto<U> for T where
        U: TryFrom<T>,     [src]

    type Error = <U as TryFrom<T>>::Error

    The type returned in the event of a conversion error.

    +
    + \ No newline at end of file diff --git a/syn/token/struct.Union.html b/syn/token/struct.Union.html index b4880bf..8125eab 100644 --- a/syn/token/struct.Union.html +++ b/syn/token/struct.Union.html @@ -1,37 +1,38 @@ -syn::token::Union - Rust +syn::token::Union - Rust -

    [−][src]Struct syn::token::Union

    pub struct Union {
+
    Struct syn::token::Union[−][src]
    pub struct Union {
     pub span: Span,
 }
    union
    
-
    Don't try to remember the name of this type — use the
+
    Don’t try to remember the name of this type — use the
 Token! macro instead.
    
 
    
                        Fields
    span: Span
    Trait Implementations
    impl Clone for Union[src]
    impl Copy for Union[src]
    impl Debug for Union[src]
    impl Default for Union[src]
    impl Default for Union[src]
    impl Eq for Union[src]
    impl Hash for Union[src]
    impl Parse for Union[src]
    impl PartialEq<Union> for Union[src]
    impl ToTokens for Union[src]
    impl Token for Union[src]
    Auto Trait Implementations
    Blanket Implementations
    impl<T> Any for T where
        T: 'static + ?Sized,     [src]
    impl<T> Borrow<T> for T where
        T: ?Sized,     [src]
    impl<T> BorrowMut<T> for T where
        T: ?Sized,     [src]
    impl<T> From<T> for T[src]
    impl<T, U> Into<U> for T where
        U: From<T>,     [src]
    impl Token for Union[src]
    Auto Trait Implementations
    impl RefUnwindSafe for Union
    impl !Send for Union
    impl !Sync for Union
    impl Unpin for Union
    impl UnwindSafe for Union
    Blanket Implementations
    impl<T> Any for T where
        T: 'static + ?Sized,     [src]
    impl<T> Borrow<T> for T where
        T: ?Sized,     [src]
    impl<T> BorrowMut<T> for T where
        T: ?Sized,     [src]
    impl<T> From<T> for T[src]
    impl<T, U> Into<U> for T where
        U: From<T>,     [src]
    impl<T> Spanned for T where
        T: Spanned + ?Sized,     [src]
    impl<T> ToOwned for T where
        T: Clone,     [src]
    type Owned = T
    The resulting type after obtaining ownership.
    
-
    impl<T> ToOwned for T where
        T: Clone,     [src]
    type Owned = T
    The resulting type after obtaining ownership.
    
+
    impl<T, U> TryFrom<U> for T where
        U: Into<T>,     [src]
    type Error = Infallible
    The type returned in the event of a conversion error.
    
-
    impl<T, U> TryInto<U> for T where
        U: TryFrom<T>,     [src]
    type Error = <U as TryFrom<T>>::Error
    The type returned in the event of a conversion error.
    
-
    
\ No newline at end of file
+

    impl<T, U> TryFrom<U> for T where
        U: Into<T>,     [src]

    type Error = Infallible

    The type returned in the event of a conversion error.

    +

    impl<T, U> TryInto<U> for T where
        U: TryFrom<T>,     [src]

    type Error = <U as TryFrom<T>>::Error

    The type returned in the event of a conversion error.

    +
    + \ No newline at end of file diff --git a/syn/token/struct.Unsafe.html b/syn/token/struct.Unsafe.html index a02fdf2..78679dd 100644 --- a/syn/token/struct.Unsafe.html +++ b/syn/token/struct.Unsafe.html @@ -1,37 +1,38 @@ -syn::token::Unsafe - Rust +syn::token::Unsafe - Rust -

    [−][src]Struct syn::token::Unsafe

    pub struct Unsafe {
+
    Struct syn::token::Unsafe[−][src]
    pub struct Unsafe {
     pub span: Span,
 }
    unsafe
    
-
    Don't try to remember the name of this type — use the
+
    Don’t try to remember the name of this type — use the
 Token! macro instead.
    
 
    
                        Fields
    span: Span
    Trait Implementations
    impl Clone for Unsafe[src]
    impl Copy for Unsafe[src]
    impl Debug for Unsafe[src]
    impl Default for Unsafe[src]
    impl Default for Unsafe[src]
    impl Eq for Unsafe[src]
    impl Hash for Unsafe[src]
    impl Parse for Unsafe[src]
    impl PartialEq<Unsafe> for Unsafe[src]
    impl ToTokens for Unsafe[src]
    impl Token for Unsafe[src]
    Auto Trait Implementations
    Blanket Implementations
    impl<T> Any for T where
        T: 'static + ?Sized,     [src]
    impl<T> Borrow<T> for T where
        T: ?Sized,     [src]
    impl<T> BorrowMut<T> for T where
        T: ?Sized,     [src]
    impl<T> From<T> for T[src]
    impl<T, U> Into<U> for T where
        U: From<T>,     [src]
    impl Token for Unsafe[src]
    Auto Trait Implementations
    impl RefUnwindSafe for Unsafe
    impl !Send for Unsafe
    impl !Sync for Unsafe
    impl Unpin for Unsafe
    impl UnwindSafe for Unsafe
    Blanket Implementations
    impl<T> Any for T where
        T: 'static + ?Sized,     [src]
    impl<T> Borrow<T> for T where
        T: ?Sized,     [src]
    impl<T> BorrowMut<T> for T where
        T: ?Sized,     [src]
    impl<T> From<T> for T[src]
    impl<T, U> Into<U> for T where
        U: From<T>,     [src]
    impl<T> Spanned for T where
        T: Spanned + ?Sized,     [src]
    impl<T> ToOwned for T where
        T: Clone,     [src]
    type Owned = T
    The resulting type after obtaining ownership.
    
-
    impl<T> ToOwned for T where
        T: Clone,     [src]
    type Owned = T
    The resulting type after obtaining ownership.
    
+
    impl<T, U> TryFrom<U> for T where
        U: Into<T>,     [src]
    type Error = Infallible
    The type returned in the event of a conversion error.
    
-
    impl<T, U> TryInto<U> for T where
        U: TryFrom<T>,     [src]
    type Error = <U as TryFrom<T>>::Error
    The type returned in the event of a conversion error.
    
-
    
\ No newline at end of file
+

    impl<T, U> TryFrom<U> for T where
        U: Into<T>,     [src]

    type Error = Infallible

    The type returned in the event of a conversion error.

    +

    impl<T, U> TryInto<U> for T where
        U: TryFrom<T>,     [src]

    type Error = <U as TryFrom<T>>::Error

    The type returned in the event of a conversion error.

    +
    + \ No newline at end of file diff --git a/syn/token/struct.Unsized.html b/syn/token/struct.Unsized.html index 897482a..f22b038 100644 --- a/syn/token/struct.Unsized.html +++ b/syn/token/struct.Unsized.html @@ -1,37 +1,38 @@ -syn::token::Unsized - Rust +syn::token::Unsized - Rust -

    [−][src]Struct syn::token::Unsized

    pub struct Unsized {
+
    Struct syn::token::Unsized[−][src]
    pub struct Unsized {
     pub span: Span,
 }
    unsized
    
-
    Don't try to remember the name of this type — use the
+
    Don’t try to remember the name of this type — use the
 Token! macro instead.
    
 
    
                        Fields
    span: Span
    Trait Implementations
    impl Clone for Unsized[src]
    impl Copy for Unsized[src]
    impl Debug for Unsized[src]
    impl Default for Unsized[src]
    impl Default for Unsized[src]
    impl Eq for Unsized[src]
    impl Hash for Unsized[src]
    impl Parse for Unsized[src]
    impl PartialEq<Unsized> for Unsized[src]
    impl ToTokens for Unsized[src]
    impl Token for Unsized[src]
    Auto Trait Implementations
    Blanket Implementations
    impl<T> Any for T where
        T: 'static + ?Sized,     [src]
    impl<T> Borrow<T> for T where
        T: ?Sized,     [src]
    impl<T> BorrowMut<T> for T where
        T: ?Sized,     [src]
    impl<T> From<T> for T[src]
    impl<T, U> Into<U> for T where
        U: From<T>,     [src]
    impl Token for Unsized[src]
    Auto Trait Implementations
    impl RefUnwindSafe for Unsized
    impl !Send for Unsized
    impl !Sync for Unsized
    impl Unpin for Unsized
    impl UnwindSafe for Unsized
    Blanket Implementations
    impl<T> Any for T where
        T: 'static + ?Sized,     [src]
    impl<T> Borrow<T> for T where
        T: ?Sized,     [src]
    impl<T> BorrowMut<T> for T where
        T: ?Sized,     [src]
    impl<T> From<T> for T[src]
    impl<T, U> Into<U> for T where
        U: From<T>,     [src]
    impl<T> Spanned for T where
        T: Spanned + ?Sized,     [src]
    impl<T> ToOwned for T where
        T: Clone,     [src]
    type Owned = T
    The resulting type after obtaining ownership.
    
-
    impl<T> ToOwned for T where
        T: Clone,     [src]
    type Owned = T
    The resulting type after obtaining ownership.
    
+
    impl<T, U> TryFrom<U> for T where
        U: Into<T>,     [src]
    type Error = Infallible
    The type returned in the event of a conversion error.
    
-
    impl<T, U> TryInto<U> for T where
        U: TryFrom<T>,     [src]
    type Error = <U as TryFrom<T>>::Error
    The type returned in the event of a conversion error.
    
-
    
\ No newline at end of file
+

    impl<T, U> TryFrom<U> for T where
        U: Into<T>,     [src]

    type Error = Infallible

    The type returned in the event of a conversion error.

    +

    impl<T, U> TryInto<U> for T where
        U: TryFrom<T>,     [src]

    type Error = <U as TryFrom<T>>::Error

    The type returned in the event of a conversion error.

    +
    + \ No newline at end of file diff --git a/syn/token/struct.Use.html b/syn/token/struct.Use.html index ab69cd1..4c5d82e 100644 --- a/syn/token/struct.Use.html +++ b/syn/token/struct.Use.html @@ -1,37 +1,38 @@ -syn::token::Use - Rust +syn::token::Use - Rust -

    [−][src]Struct syn::token::Use

    pub struct Use {
+
    Struct syn::token::Use[−][src]
    pub struct Use {
     pub span: Span,
 }
    use
    
-
    Don't try to remember the name of this type — use the
+
    Don’t try to remember the name of this type — use the
 Token! macro instead.
    
 
    
                        Fields
    span: Span
    Trait Implementations
    impl Clone for Use[src]
    impl Copy for Use[src]
    impl Debug for Use[src]
    impl Default for Use[src]
    impl Default for Use[src]
    impl Eq for Use[src]
    impl Hash for Use[src]
    impl Parse for Use[src]
    impl PartialEq<Use> for Use[src]
    impl ToTokens for Use[src]
    impl Token for Use[src]
    Auto Trait Implementations
    impl RefUnwindSafe for Use[src]
    impl !Send for Use[src]
    impl !Sync for Use[src]
    impl Unpin for Use[src]
    impl UnwindSafe for Use[src]
    Blanket Implementations
    impl<T> Any for T where
        T: 'static + ?Sized,     [src]
    impl<T> Borrow<T> for T where
        T: ?Sized,     [src]
    impl<T> BorrowMut<T> for T where
        T: ?Sized,     [src]
    impl<T> From<T> for T[src]
    impl<T, U> Into<U> for T where
        U: From<T>,     [src]
    impl Token for Use[src]
    Auto Trait Implementations
    impl RefUnwindSafe for Use
    impl !Send for Use
    impl !Sync for Use
    impl Unpin for Use
    impl UnwindSafe for Use
    Blanket Implementations
    impl<T> Any for T where
        T: 'static + ?Sized,     [src]
    impl<T> Borrow<T> for T where
        T: ?Sized,     [src]
    impl<T> BorrowMut<T> for T where
        T: ?Sized,     [src]
    impl<T> From<T> for T[src]
    impl<T, U> Into<U> for T where
        U: From<T>,     [src]
    impl<T> Spanned for T where
        T: Spanned + ?Sized,     [src]
    impl<T> ToOwned for T where
        T: Clone,     [src]
    type Owned = T
    The resulting type after obtaining ownership.
    
-
    impl<T> ToOwned for T where
        T: Clone,     [src]
    type Owned = T
    The resulting type after obtaining ownership.
    
+
    impl<T, U> TryFrom<U> for T where
        U: Into<T>,     [src]
    type Error = Infallible
    The type returned in the event of a conversion error.
    
-
    impl<T, U> TryInto<U> for T where
        U: TryFrom<T>,     [src]
    type Error = <U as TryFrom<T>>::Error
    The type returned in the event of a conversion error.
    
-
    
\ No newline at end of file
+

    impl<T, U> TryFrom<U> for T where
        U: Into<T>,     [src]

    type Error = Infallible

    The type returned in the event of a conversion error.

    +

    impl<T, U> TryInto<U> for T where
        U: TryFrom<T>,     [src]

    type Error = <U as TryFrom<T>>::Error

    The type returned in the event of a conversion error.

    +
    + \ No newline at end of file diff --git a/syn/token/struct.Virtual.html b/syn/token/struct.Virtual.html index 3330dfd..0a937c2 100644 --- a/syn/token/struct.Virtual.html +++ b/syn/token/struct.Virtual.html @@ -1,37 +1,38 @@ -syn::token::Virtual - Rust +syn::token::Virtual - Rust -

    [−][src]Struct syn::token::Virtual

    pub struct Virtual {
+
    Struct syn::token::Virtual[−][src]
    pub struct Virtual {
     pub span: Span,
 }
    virtual
    
-
    Don't try to remember the name of this type — use the
+
    Don’t try to remember the name of this type — use the
 Token! macro instead.
    
 
    
                        Fields
    span: Span
    Trait Implementations
    impl Clone for Virtual[src]
    impl Copy for Virtual[src]
    impl Debug for Virtual[src]
    impl Default for Virtual[src]
    impl Default for Virtual[src]
    impl Eq for Virtual[src]
    impl Hash for Virtual[src]
    impl Parse for Virtual[src]
    impl PartialEq<Virtual> for Virtual[src]
    impl ToTokens for Virtual[src]
    impl Token for Virtual[src]
    Auto Trait Implementations
    Blanket Implementations
    impl<T> Any for T where
        T: 'static + ?Sized,     [src]
    impl<T> Borrow<T> for T where
        T: ?Sized,     [src]
    impl<T> BorrowMut<T> for T where
        T: ?Sized,     [src]
    impl<T> From<T> for T[src]
    impl<T, U> Into<U> for T where
        U: From<T>,     [src]
    impl Token for Virtual[src]
    Auto Trait Implementations
    impl RefUnwindSafe for Virtual
    impl !Send for Virtual
    impl !Sync for Virtual
    impl Unpin for Virtual
    impl UnwindSafe for Virtual
    Blanket Implementations
    impl<T> Any for T where
        T: 'static + ?Sized,     [src]
    impl<T> Borrow<T> for T where
        T: ?Sized,     [src]
    impl<T> BorrowMut<T> for T where
        T: ?Sized,     [src]
    impl<T> From<T> for T[src]
    impl<T, U> Into<U> for T where
        U: From<T>,     [src]
    impl<T> Spanned for T where
        T: Spanned + ?Sized,     [src]
    impl<T> ToOwned for T where
        T: Clone,     [src]
    type Owned = T
    The resulting type after obtaining ownership.
    
-
    impl<T> ToOwned for T where
        T: Clone,     [src]
    type Owned = T
    The resulting type after obtaining ownership.
    
+
    impl<T, U> TryFrom<U> for T where
        U: Into<T>,     [src]
    type Error = Infallible
    The type returned in the event of a conversion error.
    
-
    impl<T, U> TryInto<U> for T where
        U: TryFrom<T>,     [src]
    type Error = <U as TryFrom<T>>::Error
    The type returned in the event of a conversion error.
    
-
    
\ No newline at end of file
+

    impl<T, U> TryFrom<U> for T where
        U: Into<T>,     [src]

    type Error = Infallible

    The type returned in the event of a conversion error.

    +

    impl<T, U> TryInto<U> for T where
        U: TryFrom<T>,     [src]

    type Error = <U as TryFrom<T>>::Error

    The type returned in the event of a conversion error.

    +
    + \ No newline at end of file diff --git a/syn/token/struct.Where.html b/syn/token/struct.Where.html index f175745..b6fbac2 100644 --- a/syn/token/struct.Where.html +++ b/syn/token/struct.Where.html @@ -1,37 +1,38 @@ -syn::token::Where - Rust +syn::token::Where - Rust -

    [−][src]Struct syn::token::Where

    pub struct Where {
+
    Struct syn::token::Where[−][src]
    pub struct Where {
     pub span: Span,
 }
    where
    
-
    Don't try to remember the name of this type — use the
+
    Don’t try to remember the name of this type — use the
 Token! macro instead.
    
 
    
                        Fields
    span: Span
    Trait Implementations
    impl Clone for Where[src]
    impl Copy for Where[src]
    impl Debug for Where[src]
    impl Default for Where[src]
    impl Default for Where[src]
    impl Eq for Where[src]
    impl Hash for Where[src]
    impl Parse for Where[src]
    impl PartialEq<Where> for Where[src]
    impl ToTokens for Where[src]
    impl Token for Where[src]
    Auto Trait Implementations
    Blanket Implementations
    impl<T> Any for T where
        T: 'static + ?Sized,     [src]
    impl<T> Borrow<T> for T where
        T: ?Sized,     [src]
    impl<T> BorrowMut<T> for T where
        T: ?Sized,     [src]
    impl<T> From<T> for T[src]
    impl<T, U> Into<U> for T where
        U: From<T>,     [src]
    impl Token for Where[src]
    Auto Trait Implementations
    impl RefUnwindSafe for Where
    impl !Send for Where
    impl !Sync for Where
    impl Unpin for Where
    impl UnwindSafe for Where
    Blanket Implementations
    impl<T> Any for T where
        T: 'static + ?Sized,     [src]
    impl<T> Borrow<T> for T where
        T: ?Sized,     [src]
    impl<T> BorrowMut<T> for T where
        T: ?Sized,     [src]
    impl<T> From<T> for T[src]
    impl<T, U> Into<U> for T where
        U: From<T>,     [src]
    impl<T> Spanned for T where
        T: Spanned + ?Sized,     [src]
    impl<T> ToOwned for T where
        T: Clone,     [src]
    type Owned = T
    The resulting type after obtaining ownership.
    
-
    impl<T> ToOwned for T where
        T: Clone,     [src]
    type Owned = T
    The resulting type after obtaining ownership.
    
+
    impl<T, U> TryFrom<U> for T where
        U: Into<T>,     [src]
    type Error = Infallible
    The type returned in the event of a conversion error.
    
-
    impl<T, U> TryInto<U> for T where
        U: TryFrom<T>,     [src]
    type Error = <U as TryFrom<T>>::Error
    The type returned in the event of a conversion error.
    
-
    
\ No newline at end of file
+

    impl<T, U> TryFrom<U> for T where
        U: Into<T>,     [src]

    type Error = Infallible

    The type returned in the event of a conversion error.

    +

    impl<T, U> TryInto<U> for T where
        U: TryFrom<T>,     [src]

    type Error = <U as TryFrom<T>>::Error

    The type returned in the event of a conversion error.

    +
    + \ No newline at end of file diff --git a/syn/token/struct.While.html b/syn/token/struct.While.html index a336e30..6f4573c 100644 --- a/syn/token/struct.While.html +++ b/syn/token/struct.While.html @@ -1,37 +1,38 @@ -syn::token::While - Rust +syn::token::While - Rust -

    [−][src]Struct syn::token::While

    pub struct While {
+
    Struct syn::token::While[−][src]
    pub struct While {
     pub span: Span,
 }
    while
    
-
    Don't try to remember the name of this type — use the
+
    Don’t try to remember the name of this type — use the
 Token! macro instead.
    
 
    
                        Fields
    span: Span
    Trait Implementations
    impl Clone for While[src]
    impl Copy for While[src]
    impl Debug for While[src]
    impl Default for While[src]
    impl Default for While[src]
    impl Eq for While[src]
    impl Hash for While[src]
    impl Parse for While[src]
    impl PartialEq<While> for While[src]
    impl ToTokens for While[src]
    impl Token for While[src]
    Auto Trait Implementations
    Blanket Implementations
    impl<T> Any for T where
        T: 'static + ?Sized,     [src]
    impl<T> Borrow<T> for T where
        T: ?Sized,     [src]
    impl<T> BorrowMut<T> for T where
        T: ?Sized,     [src]
    impl<T> From<T> for T[src]
    impl<T, U> Into<U> for T where
        U: From<T>,     [src]
    impl Token for While[src]
    Auto Trait Implementations
    impl RefUnwindSafe for While
    impl !Send for While
    impl !Sync for While
    impl Unpin for While
    impl UnwindSafe for While
    Blanket Implementations
    impl<T> Any for T where
        T: 'static + ?Sized,     [src]
    impl<T> Borrow<T> for T where
        T: ?Sized,     [src]
    impl<T> BorrowMut<T> for T where
        T: ?Sized,     [src]
    impl<T> From<T> for T[src]
    impl<T, U> Into<U> for T where
        U: From<T>,     [src]
    impl<T> Spanned for T where
        T: Spanned + ?Sized,     [src]
    impl<T> ToOwned for T where
        T: Clone,     [src]
    type Owned = T
    The resulting type after obtaining ownership.
    
-
    impl<T> ToOwned for T where
        T: Clone,     [src]
    type Owned = T
    The resulting type after obtaining ownership.
    
+
    impl<T, U> TryFrom<U> for T where
        U: Into<T>,     [src]
    type Error = Infallible
    The type returned in the event of a conversion error.
    
-
    impl<T, U> TryInto<U> for T where
        U: TryFrom<T>,     [src]
    type Error = <U as TryFrom<T>>::Error
    The type returned in the event of a conversion error.
    
-
    
\ No newline at end of file
+

    impl<T, U> TryFrom<U> for T where
        U: Into<T>,     [src]

    type Error = Infallible

    The type returned in the event of a conversion error.

    +

    impl<T, U> TryInto<U> for T where
        U: TryFrom<T>,     [src]

    type Error = <U as TryFrom<T>>::Error

    The type returned in the event of a conversion error.

    +
    + \ No newline at end of file diff --git a/syn/token/struct.Yield.html b/syn/token/struct.Yield.html index 39cd8a0..ec0139f 100644 --- a/syn/token/struct.Yield.html +++ b/syn/token/struct.Yield.html @@ -1,37 +1,38 @@ -syn::token::Yield - Rust +syn::token::Yield - Rust -

    [−][src]Struct syn::token::Yield

    pub struct Yield {
+
    Struct syn::token::Yield[−][src]
    pub struct Yield {
     pub span: Span,
 }
    yield
    
-
    Don't try to remember the name of this type — use the
+
    Don’t try to remember the name of this type — use the
 Token! macro instead.
    
 
    
                        Fields
    span: Span
    Trait Implementations
    impl Clone for Yield[src]
    impl Copy for Yield[src]
    impl Debug for Yield[src]
    impl Default for Yield[src]
    impl Default for Yield[src]
    impl Eq for Yield[src]
    impl Hash for Yield[src]
    impl Parse for Yield[src]
    impl PartialEq<Yield> for Yield[src]
    impl ToTokens for Yield[src]
    impl Token for Yield[src]
    Auto Trait Implementations
    Blanket Implementations
    impl<T> Any for T where
        T: 'static + ?Sized,     [src]
    impl<T> Borrow<T> for T where
        T: ?Sized,     [src]
    impl<T> BorrowMut<T> for T where
        T: ?Sized,     [src]
    impl<T> From<T> for T[src]
    impl<T, U> Into<U> for T where
        U: From<T>,     [src]
    impl Token for Yield[src]
    Auto Trait Implementations
    impl RefUnwindSafe for Yield
    impl !Send for Yield
    impl !Sync for Yield
    impl Unpin for Yield
    impl UnwindSafe for Yield
    Blanket Implementations
    impl<T> Any for T where
        T: 'static + ?Sized,     [src]
    impl<T> Borrow<T> for T where
        T: ?Sized,     [src]
    impl<T> BorrowMut<T> for T where
        T: ?Sized,     [src]
    impl<T> From<T> for T[src]
    impl<T, U> Into<U> for T where
        U: From<T>,     [src]
    impl<T> Spanned for T where
        T: Spanned + ?Sized,     [src]
    impl<T> ToOwned for T where
        T: Clone,     [src]
    type Owned = T
    The resulting type after obtaining ownership.
    
-
    impl<T> ToOwned for T where
        T: Clone,     [src]
    type Owned = T
    The resulting type after obtaining ownership.
    
+
    impl<T, U> TryFrom<U> for T where
        U: Into<T>,     [src]
    type Error = Infallible
    The type returned in the event of a conversion error.
    
-
    impl<T, U> TryInto<U> for T where
        U: TryFrom<T>,     [src]
    type Error = <U as TryFrom<T>>::Error
    The type returned in the event of a conversion error.
    
-
    
\ No newline at end of file
+

    impl<T, U> TryFrom<U> for T where
        U: Into<T>,     [src]

    type Error = Infallible

    The type returned in the event of a conversion error.

    +

    impl<T, U> TryInto<U> for T where
        U: TryFrom<T>,     [src]

    type Error = <U as TryFrom<T>>::Error

    The type returned in the event of a conversion error.

    +
    + \ No newline at end of file diff --git a/syn/token/trait.Token.html b/syn/token/trait.Token.html index 4ee0690..5f2b346 100644 --- a/syn/token/trait.Token.html +++ b/syn/token/trait.Token.html @@ -1,6 +1,7 @@ -syn::token::Token - Rust +syn::token::Token - Rust -

    [−][src]Trait syn::token::Token

    pub trait Token: Sealed { }

    Marker trait for types that represent single tokens.

    +

    Trait syn::token::Token[−][src]

    pub trait Token: Sealed { }

    Marker trait for types that represent single tokens.

    This trait is sealed and cannot be implemented for types outside of Syn.

    -

    Implementations on Foreign Types

    impl Token for Group[src]

    impl Token for Punct[src]

    impl Token for Literal[src]

    impl Token for TokenTree[src]

    Loading content...

    Implementors

    impl Token for Lit[src]

    impl Token for Ident[src]

    impl Token for Lifetime[src]

    impl Token for LitBool[src]

    impl Token for LitByte[src]

    impl Token for LitByteStr[src]

    impl Token for LitChar[src]

    impl Token for LitFloat[src]

    impl Token for LitInt[src]

    impl Token for LitStr[src]

    impl Token for Abstract[src]

    impl Token for Add[src]

    impl Token for AddEq[src]

    impl Token for And[src]

    impl Token for AndAnd[src]

    impl Token for AndEq[src]

    impl Token for As[src]

    impl Token for Async[src]

    impl Token for At[src]

    impl Token for Auto[src]

    impl Token for Await[src]

    impl Token for Bang[src]

    impl Token for Become[src]

    impl Token for Box[src]

    impl Token for Brace[src]

    impl Token for Bracket[src]

    impl Token for Break[src]

    impl Token for Caret[src]

    impl Token for CaretEq[src]

    impl Token for Colon2[src]

    impl Token for Colon[src]

    impl Token for Comma[src]

    impl Token for Const[src]

    impl Token for Continue[src]

    impl Token for Crate[src]

    impl Token for Default[src]

    impl Token for Div[src]

    impl Token for DivEq[src]

    impl Token for Do[src]

    impl Token for Dollar[src]

    impl Token for Dot2[src]

    impl Token for Dot3[src]

    impl Token for Dot[src]

    impl Token for DotDotEq[src]

    impl Token for Dyn[src]

    impl Token for Else[src]

    impl Token for Enum[src]

    impl Token for Eq[src]

    impl Token for EqEq[src]

    impl Token for Extern[src]

    impl Token for FatArrow[src]

    impl Token for Final[src]

    impl Token for Fn[src]

    impl Token for For[src]

    impl Token for Ge[src]

    impl Token for syn::token::Group[src]

    impl Token for Gt[src]

    impl Token for If[src]

    impl Token for Impl[src]

    impl Token for In[src]

    impl Token for LArrow[src]

    impl Token for Le[src]

    impl Token for Let[src]

    impl Token for Loop[src]

    impl Token for Lt[src]

    impl Token for Macro[src]

    impl Token for Match[src]

    impl Token for Mod[src]

    impl Token for Move[src]

    impl Token for MulEq[src]

    impl Token for Mut[src]

    impl Token for Ne[src]

    impl Token for Or[src]

    impl Token for OrEq[src]

    impl Token for OrOr[src]

    impl Token for Override[src]

    impl Token for Paren[src]

    impl Token for Pound[src]

    impl Token for Priv[src]

    impl Token for Pub[src]

    impl Token for Question[src]

    impl Token for RArrow[src]

    impl Token for Ref[src]

    impl Token for Rem[src]

    impl Token for RemEq[src]

    impl Token for Return[src]

    impl Token for SelfType[src]

    impl Token for SelfValue[src]

    impl Token for Semi[src]

    impl Token for Shl[src]

    impl Token for ShlEq[src]

    impl Token for Shr[src]

    impl Token for ShrEq[src]

    impl Token for Star[src]

    impl Token for Static[src]

    impl Token for Struct[src]

    impl Token for Sub[src]

    impl Token for SubEq[src]

    impl Token for Super[src]

    impl Token for Tilde[src]

    impl Token for Trait[src]

    impl Token for Try[src]

    impl Token for Type[src]

    impl Token for Typeof[src]

    impl Token for Underscore[src]

    impl Token for Union[src]

    impl Token for Unsafe[src]

    impl Token for Unsized[src]

    impl Token for Use[src]

    impl Token for Virtual[src]

    impl Token for Where[src]

    impl Token for While[src]

    impl Token for Yield[src]

    impl<T: CustomToken> Token for T[src]

    Loading content...
    \ No newline at end of file +

    Implementations on Foreign Types

    impl Token for Group[src]

    impl Token for Punct[src]

    impl Token for Literal[src]

    impl Token for TokenTree[src]

    Loading content...

    Implementors

    impl Token for Lit[src]

    impl Token for Ident[src]

    impl Token for Lifetime[src]

    impl Token for LitBool[src]

    impl Token for LitByte[src]

    impl Token for LitByteStr[src]

    impl Token for LitChar[src]

    impl Token for LitFloat[src]

    impl Token for LitInt[src]

    impl Token for LitStr[src]

    impl Token for Abstract[src]

    impl Token for Add[src]

    impl Token for AddEq[src]

    impl Token for And[src]

    impl Token for AndAnd[src]

    impl Token for AndEq[src]

    impl Token for As[src]

    impl Token for Async[src]

    impl Token for At[src]

    impl Token for Auto[src]

    impl Token for Await[src]

    impl Token for Bang[src]

    impl Token for Become[src]

    impl Token for Box[src]

    impl Token for Brace[src]

    impl Token for Bracket[src]

    impl Token for Break[src]

    impl Token for Caret[src]

    impl Token for CaretEq[src]

    impl Token for Colon2[src]

    impl Token for Colon[src]

    impl Token for Comma[src]

    impl Token for Const[src]

    impl Token for Continue[src]

    impl Token for Crate[src]

    impl Token for Default[src]

    impl Token for Div[src]

    impl Token for DivEq[src]

    impl Token for Do[src]

    impl Token for Dollar[src]

    impl Token for Dot2[src]

    impl Token for Dot3[src]

    impl Token for Dot[src]

    impl Token for DotDotEq[src]

    impl Token for Dyn[src]

    impl Token for Else[src]

    impl Token for Enum[src]

    impl Token for Eq[src]

    impl Token for EqEq[src]

    impl Token for Extern[src]

    impl Token for FatArrow[src]

    impl Token for Final[src]

    impl Token for Fn[src]

    impl Token for For[src]

    impl Token for Ge[src]

    impl Token for syn::token::Group[src]

    impl Token for Gt[src]

    impl Token for If[src]

    impl Token for Impl[src]

    impl Token for In[src]

    impl Token for LArrow[src]

    impl Token for Le[src]

    impl Token for Let[src]

    impl Token for Loop[src]

    impl Token for Lt[src]

    impl Token for Macro[src]

    impl Token for Match[src]

    impl Token for Mod[src]

    impl Token for Move[src]

    impl Token for MulEq[src]

    impl Token for Mut[src]

    impl Token for Ne[src]

    impl Token for Or[src]

    impl Token for OrEq[src]

    impl Token for OrOr[src]

    impl Token for Override[src]

    impl Token for Paren[src]

    impl Token for Pound[src]

    impl Token for Priv[src]

    impl Token for Pub[src]

    impl Token for Question[src]

    impl Token for RArrow[src]

    impl Token for Ref[src]

    impl Token for Rem[src]

    impl Token for RemEq[src]

    impl Token for Return[src]

    impl Token for SelfType[src]

    impl Token for SelfValue[src]

    impl Token for Semi[src]

    impl Token for Shl[src]

    impl Token for ShlEq[src]

    impl Token for Shr[src]

    impl Token for ShrEq[src]

    impl Token for Star[src]

    impl Token for Static[src]

    impl Token for Struct[src]

    impl Token for Sub[src]

    impl Token for SubEq[src]

    impl Token for Super[src]

    impl Token for Tilde[src]

    impl Token for Trait[src]

    impl Token for Try[src]

    impl Token for Type[src]

    impl Token for Typeof[src]

    impl Token for Underscore[src]

    impl Token for Union[src]

    impl Token for Unsafe[src]

    impl Token for Unsized[src]

    impl Token for Use[src]

    impl Token for Virtual[src]

    impl Token for Where[src]

    impl Token for While[src]

    impl Token for Yield[src]

    impl<T: CustomToken> Token for T[src]

    Loading content...
    + \ No newline at end of file diff --git a/syn/type.AttributeArgs.html b/syn/type.AttributeArgs.html index 234b00c..37f7897 100644 --- a/syn/type.AttributeArgs.html +++ b/syn/type.AttributeArgs.html @@ -1,7 +1,7 @@ -syn::AttributeArgs - Rust +syn::AttributeArgs - Rust -

    [−][src]Type Definition syn::AttributeArgs

    type AttributeArgs = Vec<NestedMeta>;

    Conventional argument type associated with an invocation of an attribute +

    Type Definition syn::AttributeArgs[−][src]

    type AttributeArgs = Vec<NestedMeta>;

    Conventional argument type associated with an invocation of an attribute macro.

    For example if we are developing an attribute macro that is intended to be invoked on function items as follows:

    @@ -25,4 +25,5 @@ as type AttributeArgs.

    /* ... */ }
    -
    \ No newline at end of file +
    + \ No newline at end of file diff --git a/syn/type.Result.html b/syn/type.Result.html index 31d8584..1dc86a5 100644 --- a/syn/type.Result.html +++ b/syn/type.Result.html @@ -1,5 +1,6 @@ -syn::Result - Rust +syn::Result - Rust -

    [−][src]Type Definition syn::Result

    type Result<T> = Result<T, Error>;

    The result of a Syn parser.

    -
    \ No newline at end of file +

    Type Definition syn::Result[−][src]

    type Result<T> = Result<T, Error>;

    The result of a Syn parser.

    +
    + \ No newline at end of file diff --git a/syn/visit/fn.visit_abi.html b/syn/visit/fn.visit_abi.html index c54600b..ec50144 100644 --- a/syn/visit/fn.visit_abi.html +++ b/syn/visit/fn.visit_abi.html @@ -1,4 +1,5 @@ -syn::visit::visit_abi - Rust +syn::visit::visit_abi - Rust -

    [−][src]Function syn::visit::visit_abi

    pub fn visit_abi<'ast, V: ?Sized>(v: &mut V, node: &'ast Abi) where
        V: Visit<'ast>, 
    \ No newline at end of file +

    Function syn::visit::visit_abi[−][src]

    pub fn visit_abi<'ast, V: ?Sized>(v: &mut V, node: &'ast Abi) where
        V: Visit<'ast>, 
    + \ No newline at end of file diff --git a/syn/visit/fn.visit_angle_bracketed_generic_arguments.html b/syn/visit/fn.visit_angle_bracketed_generic_arguments.html index 9ec6c31..657d999 100644 --- a/syn/visit/fn.visit_angle_bracketed_generic_arguments.html +++ b/syn/visit/fn.visit_angle_bracketed_generic_arguments.html @@ -1,4 +1,5 @@ -syn::visit::visit_angle_bracketed_generic_arguments - Rust +syn::visit::visit_angle_bracketed_generic_arguments - Rust -

    [−][src]Function syn::visit::visit_angle_bracketed_generic_arguments

    pub fn visit_angle_bracketed_generic_arguments<'ast, V: ?Sized>(
        v: &mut V, 
        node: &'ast AngleBracketedGenericArguments
    ) where
        V: Visit<'ast>, 
    \ No newline at end of file +

    Function syn::visit::visit_angle_bracketed_generic_arguments[−][src]

    pub fn visit_angle_bracketed_generic_arguments<'ast, V: ?Sized>(
        v: &mut V, 
        node: &'ast AngleBracketedGenericArguments
    ) where
        V: Visit<'ast>, 
    + \ No newline at end of file diff --git a/syn/visit/fn.visit_attr_style.html b/syn/visit/fn.visit_attr_style.html index 2f2b578..3acbea7 100644 --- a/syn/visit/fn.visit_attr_style.html +++ b/syn/visit/fn.visit_attr_style.html @@ -1,4 +1,5 @@ -syn::visit::visit_attr_style - Rust +syn::visit::visit_attr_style - Rust -

    [−][src]Function syn::visit::visit_attr_style

    pub fn visit_attr_style<'ast, V: ?Sized>(v: &mut V, node: &'ast AttrStyle) where
        V: Visit<'ast>, 
    \ No newline at end of file +

    Function syn::visit::visit_attr_style[−][src]

    pub fn visit_attr_style<'ast, V: ?Sized>(v: &mut V, node: &'ast AttrStyle) where
        V: Visit<'ast>, 
    + \ No newline at end of file diff --git a/syn/visit/fn.visit_attribute.html b/syn/visit/fn.visit_attribute.html index 8343ed3..01f39f5 100644 --- a/syn/visit/fn.visit_attribute.html +++ b/syn/visit/fn.visit_attribute.html @@ -1,4 +1,5 @@ -syn::visit::visit_attribute - Rust +syn::visit::visit_attribute - Rust -

    [−][src]Function syn::visit::visit_attribute

    pub fn visit_attribute<'ast, V: ?Sized>(v: &mut V, node: &'ast Attribute) where
        V: Visit<'ast>, 
    \ No newline at end of file +

    Function syn::visit::visit_attribute[−][src]

    pub fn visit_attribute<'ast, V: ?Sized>(v: &mut V, node: &'ast Attribute) where
        V: Visit<'ast>, 
    + \ No newline at end of file diff --git a/syn/visit/fn.visit_bare_fn_arg.html b/syn/visit/fn.visit_bare_fn_arg.html index 375ee72..5d1f30c 100644 --- a/syn/visit/fn.visit_bare_fn_arg.html +++ b/syn/visit/fn.visit_bare_fn_arg.html @@ -1,4 +1,5 @@ -syn::visit::visit_bare_fn_arg - Rust +syn::visit::visit_bare_fn_arg - Rust -

    [−][src]Function syn::visit::visit_bare_fn_arg

    pub fn visit_bare_fn_arg<'ast, V: ?Sized>(v: &mut V, node: &'ast BareFnArg) where
        V: Visit<'ast>, 
    \ No newline at end of file +

    Function syn::visit::visit_bare_fn_arg[−][src]

    pub fn visit_bare_fn_arg<'ast, V: ?Sized>(v: &mut V, node: &'ast BareFnArg) where
        V: Visit<'ast>, 
    + \ No newline at end of file diff --git a/syn/visit/fn.visit_bin_op.html b/syn/visit/fn.visit_bin_op.html index c4dda40..e43b868 100644 --- a/syn/visit/fn.visit_bin_op.html +++ b/syn/visit/fn.visit_bin_op.html @@ -1,4 +1,5 @@ -syn::visit::visit_bin_op - Rust +syn::visit::visit_bin_op - Rust -

    [−][src]Function syn::visit::visit_bin_op

    pub fn visit_bin_op<'ast, V: ?Sized>(v: &mut V, node: &'ast BinOp) where
        V: Visit<'ast>, 
    \ No newline at end of file +

    Function syn::visit::visit_bin_op[−][src]

    pub fn visit_bin_op<'ast, V: ?Sized>(v: &mut V, node: &'ast BinOp) where
        V: Visit<'ast>, 
    + \ No newline at end of file diff --git a/syn/visit/fn.visit_binding.html b/syn/visit/fn.visit_binding.html index 304c8b6..faff1d1 100644 --- a/syn/visit/fn.visit_binding.html +++ b/syn/visit/fn.visit_binding.html @@ -1,4 +1,5 @@ -syn::visit::visit_binding - Rust +syn::visit::visit_binding - Rust -

    [−][src]Function syn::visit::visit_binding

    pub fn visit_binding<'ast, V: ?Sized>(v: &mut V, node: &'ast Binding) where
        V: Visit<'ast>, 
    \ No newline at end of file +

    Function syn::visit::visit_binding[−][src]

    pub fn visit_binding<'ast, V: ?Sized>(v: &mut V, node: &'ast Binding) where
        V: Visit<'ast>, 
    + \ No newline at end of file diff --git a/syn/visit/fn.visit_bound_lifetimes.html b/syn/visit/fn.visit_bound_lifetimes.html index 2fcf9a0..e056212 100644 --- a/syn/visit/fn.visit_bound_lifetimes.html +++ b/syn/visit/fn.visit_bound_lifetimes.html @@ -1,4 +1,5 @@ -syn::visit::visit_bound_lifetimes - Rust +syn::visit::visit_bound_lifetimes - Rust -

    [−][src]Function syn::visit::visit_bound_lifetimes

    pub fn visit_bound_lifetimes<'ast, V: ?Sized>(
        v: &mut V, 
        node: &'ast BoundLifetimes
    ) where
        V: Visit<'ast>, 
    \ No newline at end of file +

    Function syn::visit::visit_bound_lifetimes[−][src]

    pub fn visit_bound_lifetimes<'ast, V: ?Sized>(
        v: &mut V, 
        node: &'ast BoundLifetimes
    ) where
        V: Visit<'ast>, 
    + \ No newline at end of file diff --git a/syn/visit/fn.visit_const_param.html b/syn/visit/fn.visit_const_param.html index 0e5a04b..a9f750e 100644 --- a/syn/visit/fn.visit_const_param.html +++ b/syn/visit/fn.visit_const_param.html @@ -1,4 +1,5 @@ -syn::visit::visit_const_param - Rust +syn::visit::visit_const_param - Rust -

    [−][src]Function syn::visit::visit_const_param

    pub fn visit_const_param<'ast, V: ?Sized>(v: &mut V, node: &'ast ConstParam) where
        V: Visit<'ast>, 
    \ No newline at end of file +

    Function syn::visit::visit_const_param[−][src]

    pub fn visit_const_param<'ast, V: ?Sized>(v: &mut V, node: &'ast ConstParam) where
        V: Visit<'ast>, 
    + \ No newline at end of file diff --git a/syn/visit/fn.visit_constraint.html b/syn/visit/fn.visit_constraint.html index 2a5a1e8..52ff20c 100644 --- a/syn/visit/fn.visit_constraint.html +++ b/syn/visit/fn.visit_constraint.html @@ -1,4 +1,5 @@ -syn::visit::visit_constraint - Rust +syn::visit::visit_constraint - Rust -

    [−][src]Function syn::visit::visit_constraint

    pub fn visit_constraint<'ast, V: ?Sized>(v: &mut V, node: &'ast Constraint) where
        V: Visit<'ast>, 
    \ No newline at end of file +

    Function syn::visit::visit_constraint[−][src]

    pub fn visit_constraint<'ast, V: ?Sized>(v: &mut V, node: &'ast Constraint) where
        V: Visit<'ast>, 
    + \ No newline at end of file diff --git a/syn/visit/fn.visit_data.html b/syn/visit/fn.visit_data.html index 8f18fd0..c2bae7f 100644 --- a/syn/visit/fn.visit_data.html +++ b/syn/visit/fn.visit_data.html @@ -1,4 +1,5 @@ -syn::visit::visit_data - Rust +syn::visit::visit_data - Rust -

    [−][src]Function syn::visit::visit_data

    pub fn visit_data<'ast, V: ?Sized>(v: &mut V, node: &'ast Data) where
        V: Visit<'ast>, 
    \ No newline at end of file +

    Function syn::visit::visit_data[−][src]

    pub fn visit_data<'ast, V: ?Sized>(v: &mut V, node: &'ast Data) where
        V: Visit<'ast>, 
    + \ No newline at end of file diff --git a/syn/visit/fn.visit_data_enum.html b/syn/visit/fn.visit_data_enum.html index 2fcaebe..108ead8 100644 --- a/syn/visit/fn.visit_data_enum.html +++ b/syn/visit/fn.visit_data_enum.html @@ -1,4 +1,5 @@ -syn::visit::visit_data_enum - Rust +syn::visit::visit_data_enum - Rust -

    [−][src]Function syn::visit::visit_data_enum

    pub fn visit_data_enum<'ast, V: ?Sized>(v: &mut V, node: &'ast DataEnum) where
        V: Visit<'ast>, 
    \ No newline at end of file +

    Function syn::visit::visit_data_enum[−][src]

    pub fn visit_data_enum<'ast, V: ?Sized>(v: &mut V, node: &'ast DataEnum) where
        V: Visit<'ast>, 
    + \ No newline at end of file diff --git a/syn/visit/fn.visit_data_struct.html b/syn/visit/fn.visit_data_struct.html index e90ff4f..0aa09ab 100644 --- a/syn/visit/fn.visit_data_struct.html +++ b/syn/visit/fn.visit_data_struct.html @@ -1,4 +1,5 @@ -syn::visit::visit_data_struct - Rust +syn::visit::visit_data_struct - Rust -

    [−][src]Function syn::visit::visit_data_struct

    pub fn visit_data_struct<'ast, V: ?Sized>(v: &mut V, node: &'ast DataStruct) where
        V: Visit<'ast>, 
    \ No newline at end of file +

    Function syn::visit::visit_data_struct[−][src]

    pub fn visit_data_struct<'ast, V: ?Sized>(v: &mut V, node: &'ast DataStruct) where
        V: Visit<'ast>, 
    + \ No newline at end of file diff --git a/syn/visit/fn.visit_data_union.html b/syn/visit/fn.visit_data_union.html index 42cec1b..7264089 100644 --- a/syn/visit/fn.visit_data_union.html +++ b/syn/visit/fn.visit_data_union.html @@ -1,4 +1,5 @@ -syn::visit::visit_data_union - Rust +syn::visit::visit_data_union - Rust -

    [−][src]Function syn::visit::visit_data_union

    pub fn visit_data_union<'ast, V: ?Sized>(v: &mut V, node: &'ast DataUnion) where
        V: Visit<'ast>, 
    \ No newline at end of file +

    Function syn::visit::visit_data_union[−][src]

    pub fn visit_data_union<'ast, V: ?Sized>(v: &mut V, node: &'ast DataUnion) where
        V: Visit<'ast>, 
    + \ No newline at end of file diff --git a/syn/visit/fn.visit_derive_input.html b/syn/visit/fn.visit_derive_input.html index 6fb704e..a2cee50 100644 --- a/syn/visit/fn.visit_derive_input.html +++ b/syn/visit/fn.visit_derive_input.html @@ -1,4 +1,5 @@ -syn::visit::visit_derive_input - Rust +syn::visit::visit_derive_input - Rust -

    [−][src]Function syn::visit::visit_derive_input

    pub fn visit_derive_input<'ast, V: ?Sized>(v: &mut V, node: &'ast DeriveInput) where
        V: Visit<'ast>, 
    \ No newline at end of file +

    Function syn::visit::visit_derive_input[−][src]

    pub fn visit_derive_input<'ast, V: ?Sized>(v: &mut V, node: &'ast DeriveInput) where
        V: Visit<'ast>, 
    + \ No newline at end of file diff --git a/syn/visit/fn.visit_expr.html b/syn/visit/fn.visit_expr.html index 15663f7..3983faf 100644 --- a/syn/visit/fn.visit_expr.html +++ b/syn/visit/fn.visit_expr.html @@ -1,4 +1,5 @@ -syn::visit::visit_expr - Rust +syn::visit::visit_expr - Rust -

    [−][src]Function syn::visit::visit_expr

    pub fn visit_expr<'ast, V: ?Sized>(v: &mut V, node: &'ast Expr) where
        V: Visit<'ast>, 
    \ No newline at end of file +

    Function syn::visit::visit_expr[−][src]

    pub fn visit_expr<'ast, V: ?Sized>(v: &mut V, node: &'ast Expr) where
        V: Visit<'ast>, 
    + \ No newline at end of file diff --git a/syn/visit/fn.visit_expr_binary.html b/syn/visit/fn.visit_expr_binary.html index 2a097bf..d42b1b2 100644 --- a/syn/visit/fn.visit_expr_binary.html +++ b/syn/visit/fn.visit_expr_binary.html @@ -1,4 +1,5 @@ -syn::visit::visit_expr_binary - Rust +syn::visit::visit_expr_binary - Rust -

    [−][src]Function syn::visit::visit_expr_binary

    pub fn visit_expr_binary<'ast, V: ?Sized>(v: &mut V, node: &'ast ExprBinary) where
        V: Visit<'ast>, 
    \ No newline at end of file +

    Function syn::visit::visit_expr_binary[−][src]

    pub fn visit_expr_binary<'ast, V: ?Sized>(v: &mut V, node: &'ast ExprBinary) where
        V: Visit<'ast>, 
    + \ No newline at end of file diff --git a/syn/visit/fn.visit_expr_call.html b/syn/visit/fn.visit_expr_call.html index 95a1a0e..bba320a 100644 --- a/syn/visit/fn.visit_expr_call.html +++ b/syn/visit/fn.visit_expr_call.html @@ -1,4 +1,5 @@ -syn::visit::visit_expr_call - Rust +syn::visit::visit_expr_call - Rust -

    [−][src]Function syn::visit::visit_expr_call

    pub fn visit_expr_call<'ast, V: ?Sized>(v: &mut V, node: &'ast ExprCall) where
        V: Visit<'ast>, 
    \ No newline at end of file +

    Function syn::visit::visit_expr_call[−][src]

    pub fn visit_expr_call<'ast, V: ?Sized>(v: &mut V, node: &'ast ExprCall) where
        V: Visit<'ast>, 
    + \ No newline at end of file diff --git a/syn/visit/fn.visit_expr_cast.html b/syn/visit/fn.visit_expr_cast.html index fa1e81e..79024aa 100644 --- a/syn/visit/fn.visit_expr_cast.html +++ b/syn/visit/fn.visit_expr_cast.html @@ -1,4 +1,5 @@ -syn::visit::visit_expr_cast - Rust +syn::visit::visit_expr_cast - Rust -

    [−][src]Function syn::visit::visit_expr_cast

    pub fn visit_expr_cast<'ast, V: ?Sized>(v: &mut V, node: &'ast ExprCast) where
        V: Visit<'ast>, 
    \ No newline at end of file +

    Function syn::visit::visit_expr_cast[−][src]

    pub fn visit_expr_cast<'ast, V: ?Sized>(v: &mut V, node: &'ast ExprCast) where
        V: Visit<'ast>, 
    + \ No newline at end of file diff --git a/syn/visit/fn.visit_expr_field.html b/syn/visit/fn.visit_expr_field.html index b8ac29f..7544389 100644 --- a/syn/visit/fn.visit_expr_field.html +++ b/syn/visit/fn.visit_expr_field.html @@ -1,4 +1,5 @@ -syn::visit::visit_expr_field - Rust +syn::visit::visit_expr_field - Rust -

    [−][src]Function syn::visit::visit_expr_field

    pub fn visit_expr_field<'ast, V: ?Sized>(v: &mut V, node: &'ast ExprField) where
        V: Visit<'ast>, 
    \ No newline at end of file +

    Function syn::visit::visit_expr_field[−][src]

    pub fn visit_expr_field<'ast, V: ?Sized>(v: &mut V, node: &'ast ExprField) where
        V: Visit<'ast>, 
    + \ No newline at end of file diff --git a/syn/visit/fn.visit_expr_index.html b/syn/visit/fn.visit_expr_index.html index e6769a1..983556d 100644 --- a/syn/visit/fn.visit_expr_index.html +++ b/syn/visit/fn.visit_expr_index.html @@ -1,4 +1,5 @@ -syn::visit::visit_expr_index - Rust +syn::visit::visit_expr_index - Rust -

    [−][src]Function syn::visit::visit_expr_index

    pub fn visit_expr_index<'ast, V: ?Sized>(v: &mut V, node: &'ast ExprIndex) where
        V: Visit<'ast>, 
    \ No newline at end of file +

    Function syn::visit::visit_expr_index[−][src]

    pub fn visit_expr_index<'ast, V: ?Sized>(v: &mut V, node: &'ast ExprIndex) where
        V: Visit<'ast>, 
    + \ No newline at end of file diff --git a/syn/visit/fn.visit_expr_lit.html b/syn/visit/fn.visit_expr_lit.html index 2aa5caa..a1e1d06 100644 --- a/syn/visit/fn.visit_expr_lit.html +++ b/syn/visit/fn.visit_expr_lit.html @@ -1,4 +1,5 @@ -syn::visit::visit_expr_lit - Rust +syn::visit::visit_expr_lit - Rust -

    [−][src]Function syn::visit::visit_expr_lit

    pub fn visit_expr_lit<'ast, V: ?Sized>(v: &mut V, node: &'ast ExprLit) where
        V: Visit<'ast>, 
    \ No newline at end of file +

    Function syn::visit::visit_expr_lit[−][src]

    pub fn visit_expr_lit<'ast, V: ?Sized>(v: &mut V, node: &'ast ExprLit) where
        V: Visit<'ast>, 
    + \ No newline at end of file diff --git a/syn/visit/fn.visit_expr_paren.html b/syn/visit/fn.visit_expr_paren.html index aca1338..e051eb4 100644 --- a/syn/visit/fn.visit_expr_paren.html +++ b/syn/visit/fn.visit_expr_paren.html @@ -1,4 +1,5 @@ -syn::visit::visit_expr_paren - Rust +syn::visit::visit_expr_paren - Rust -

    [−][src]Function syn::visit::visit_expr_paren

    pub fn visit_expr_paren<'ast, V: ?Sized>(v: &mut V, node: &'ast ExprParen) where
        V: Visit<'ast>, 
    \ No newline at end of file +

    Function syn::visit::visit_expr_paren[−][src]

    pub fn visit_expr_paren<'ast, V: ?Sized>(v: &mut V, node: &'ast ExprParen) where
        V: Visit<'ast>, 
    + \ No newline at end of file diff --git a/syn/visit/fn.visit_expr_path.html b/syn/visit/fn.visit_expr_path.html index 8fad5a3..6daf0d4 100644 --- a/syn/visit/fn.visit_expr_path.html +++ b/syn/visit/fn.visit_expr_path.html @@ -1,4 +1,5 @@ -syn::visit::visit_expr_path - Rust +syn::visit::visit_expr_path - Rust -

    [−][src]Function syn::visit::visit_expr_path

    pub fn visit_expr_path<'ast, V: ?Sized>(v: &mut V, node: &'ast ExprPath) where
        V: Visit<'ast>, 
    \ No newline at end of file +

    Function syn::visit::visit_expr_path[−][src]

    pub fn visit_expr_path<'ast, V: ?Sized>(v: &mut V, node: &'ast ExprPath) where
        V: Visit<'ast>, 
    + \ No newline at end of file diff --git a/syn/visit/fn.visit_expr_unary.html b/syn/visit/fn.visit_expr_unary.html index d718e38..78d1173 100644 --- a/syn/visit/fn.visit_expr_unary.html +++ b/syn/visit/fn.visit_expr_unary.html @@ -1,4 +1,5 @@ -syn::visit::visit_expr_unary - Rust +syn::visit::visit_expr_unary - Rust -

    [−][src]Function syn::visit::visit_expr_unary

    pub fn visit_expr_unary<'ast, V: ?Sized>(v: &mut V, node: &'ast ExprUnary) where
        V: Visit<'ast>, 
    \ No newline at end of file +

    Function syn::visit::visit_expr_unary[−][src]

    pub fn visit_expr_unary<'ast, V: ?Sized>(v: &mut V, node: &'ast ExprUnary) where
        V: Visit<'ast>, 
    + \ No newline at end of file diff --git a/syn/visit/fn.visit_field.html b/syn/visit/fn.visit_field.html index 4265d8d..e6fa1f2 100644 --- a/syn/visit/fn.visit_field.html +++ b/syn/visit/fn.visit_field.html @@ -1,4 +1,5 @@ -syn::visit::visit_field - Rust +syn::visit::visit_field - Rust -

    [−][src]Function syn::visit::visit_field

    pub fn visit_field<'ast, V: ?Sized>(v: &mut V, node: &'ast Field) where
        V: Visit<'ast>, 
    \ No newline at end of file +

    Function syn::visit::visit_field[−][src]

    pub fn visit_field<'ast, V: ?Sized>(v: &mut V, node: &'ast Field) where
        V: Visit<'ast>, 
    + \ No newline at end of file diff --git a/syn/visit/fn.visit_fields.html b/syn/visit/fn.visit_fields.html index eb03061..c90e8f4 100644 --- a/syn/visit/fn.visit_fields.html +++ b/syn/visit/fn.visit_fields.html @@ -1,4 +1,5 @@ -syn::visit::visit_fields - Rust +syn::visit::visit_fields - Rust -

    [−][src]Function syn::visit::visit_fields

    pub fn visit_fields<'ast, V: ?Sized>(v: &mut V, node: &'ast Fields) where
        V: Visit<'ast>, 
    \ No newline at end of file +

    Function syn::visit::visit_fields[−][src]

    pub fn visit_fields<'ast, V: ?Sized>(v: &mut V, node: &'ast Fields) where
        V: Visit<'ast>, 
    + \ No newline at end of file diff --git a/syn/visit/fn.visit_fields_named.html b/syn/visit/fn.visit_fields_named.html index 8ec6198..25438be 100644 --- a/syn/visit/fn.visit_fields_named.html +++ b/syn/visit/fn.visit_fields_named.html @@ -1,4 +1,5 @@ -syn::visit::visit_fields_named - Rust +syn::visit::visit_fields_named - Rust -

    [−][src]Function syn::visit::visit_fields_named

    pub fn visit_fields_named<'ast, V: ?Sized>(v: &mut V, node: &'ast FieldsNamed) where
        V: Visit<'ast>, 
    \ No newline at end of file +

    Function syn::visit::visit_fields_named[−][src]

    pub fn visit_fields_named<'ast, V: ?Sized>(v: &mut V, node: &'ast FieldsNamed) where
        V: Visit<'ast>, 
    + \ No newline at end of file diff --git a/syn/visit/fn.visit_fields_unnamed.html b/syn/visit/fn.visit_fields_unnamed.html index 1e5e7c6..088fc37 100644 --- a/syn/visit/fn.visit_fields_unnamed.html +++ b/syn/visit/fn.visit_fields_unnamed.html @@ -1,4 +1,5 @@ -syn::visit::visit_fields_unnamed - Rust +syn::visit::visit_fields_unnamed - Rust -

    [−][src]Function syn::visit::visit_fields_unnamed

    pub fn visit_fields_unnamed<'ast, V: ?Sized>(
        v: &mut V, 
        node: &'ast FieldsUnnamed
    ) where
        V: Visit<'ast>, 
    \ No newline at end of file +

    Function syn::visit::visit_fields_unnamed[−][src]

    pub fn visit_fields_unnamed<'ast, V: ?Sized>(
        v: &mut V, 
        node: &'ast FieldsUnnamed
    ) where
        V: Visit<'ast>, 
    + \ No newline at end of file diff --git a/syn/visit/fn.visit_generic_argument.html b/syn/visit/fn.visit_generic_argument.html index 391155e..3b44a0e 100644 --- a/syn/visit/fn.visit_generic_argument.html +++ b/syn/visit/fn.visit_generic_argument.html @@ -1,4 +1,5 @@ -syn::visit::visit_generic_argument - Rust +syn::visit::visit_generic_argument - Rust -

    [−][src]Function syn::visit::visit_generic_argument

    pub fn visit_generic_argument<'ast, V: ?Sized>(
        v: &mut V, 
        node: &'ast GenericArgument
    ) where
        V: Visit<'ast>, 
    \ No newline at end of file +

    Function syn::visit::visit_generic_argument[−][src]

    pub fn visit_generic_argument<'ast, V: ?Sized>(
        v: &mut V, 
        node: &'ast GenericArgument
    ) where
        V: Visit<'ast>, 
    + \ No newline at end of file diff --git a/syn/visit/fn.visit_generic_param.html b/syn/visit/fn.visit_generic_param.html index a8ec82b..271b35c 100644 --- a/syn/visit/fn.visit_generic_param.html +++ b/syn/visit/fn.visit_generic_param.html @@ -1,4 +1,5 @@ -syn::visit::visit_generic_param - Rust +syn::visit::visit_generic_param - Rust -

    [−][src]Function syn::visit::visit_generic_param

    pub fn visit_generic_param<'ast, V: ?Sized>(v: &mut V, node: &'ast GenericParam) where
        V: Visit<'ast>, 
    \ No newline at end of file +

    Function syn::visit::visit_generic_param[−][src]

    pub fn visit_generic_param<'ast, V: ?Sized>(v: &mut V, node: &'ast GenericParam) where
        V: Visit<'ast>, 
    + \ No newline at end of file diff --git a/syn/visit/fn.visit_generics.html b/syn/visit/fn.visit_generics.html index 58d18b0..12d296a 100644 --- a/syn/visit/fn.visit_generics.html +++ b/syn/visit/fn.visit_generics.html @@ -1,4 +1,5 @@ -syn::visit::visit_generics - Rust +syn::visit::visit_generics - Rust -

    [−][src]Function syn::visit::visit_generics

    pub fn visit_generics<'ast, V: ?Sized>(v: &mut V, node: &'ast Generics) where
        V: Visit<'ast>, 
    \ No newline at end of file +

    Function syn::visit::visit_generics[−][src]

    pub fn visit_generics<'ast, V: ?Sized>(v: &mut V, node: &'ast Generics) where
        V: Visit<'ast>, 
    + \ No newline at end of file diff --git a/syn/visit/fn.visit_ident.html b/syn/visit/fn.visit_ident.html index 1f36388..d6ceb28 100644 --- a/syn/visit/fn.visit_ident.html +++ b/syn/visit/fn.visit_ident.html @@ -1,4 +1,5 @@ -syn::visit::visit_ident - Rust +syn::visit::visit_ident - Rust -

    [−][src]Function syn::visit::visit_ident

    pub fn visit_ident<'ast, V: ?Sized>(v: &mut V, node: &'ast Ident) where
        V: Visit<'ast>, 
    \ No newline at end of file +

    Function syn::visit::visit_ident[−][src]

    pub fn visit_ident<'ast, V: ?Sized>(v: &mut V, node: &'ast Ident) where
        V: Visit<'ast>, 
    + \ No newline at end of file diff --git a/syn/visit/fn.visit_index.html b/syn/visit/fn.visit_index.html index f987e0e..eea2c6c 100644 --- a/syn/visit/fn.visit_index.html +++ b/syn/visit/fn.visit_index.html @@ -1,4 +1,5 @@ -syn::visit::visit_index - Rust +syn::visit::visit_index - Rust -

    [−][src]Function syn::visit::visit_index

    pub fn visit_index<'ast, V: ?Sized>(v: &mut V, node: &'ast Index) where
        V: Visit<'ast>, 
    \ No newline at end of file +

    Function syn::visit::visit_index[−][src]

    pub fn visit_index<'ast, V: ?Sized>(v: &mut V, node: &'ast Index) where
        V: Visit<'ast>, 
    + \ No newline at end of file diff --git a/syn/visit/fn.visit_lifetime.html b/syn/visit/fn.visit_lifetime.html index daf3564..66e663f 100644 --- a/syn/visit/fn.visit_lifetime.html +++ b/syn/visit/fn.visit_lifetime.html @@ -1,4 +1,5 @@ -syn::visit::visit_lifetime - Rust +syn::visit::visit_lifetime - Rust -

    [−][src]Function syn::visit::visit_lifetime

    pub fn visit_lifetime<'ast, V: ?Sized>(v: &mut V, node: &'ast Lifetime) where
        V: Visit<'ast>, 
    \ No newline at end of file +

    Function syn::visit::visit_lifetime[−][src]

    pub fn visit_lifetime<'ast, V: ?Sized>(v: &mut V, node: &'ast Lifetime) where
        V: Visit<'ast>, 
    + \ No newline at end of file diff --git a/syn/visit/fn.visit_lifetime_def.html b/syn/visit/fn.visit_lifetime_def.html index e93f05a..deb5005 100644 --- a/syn/visit/fn.visit_lifetime_def.html +++ b/syn/visit/fn.visit_lifetime_def.html @@ -1,4 +1,5 @@ -syn::visit::visit_lifetime_def - Rust +syn::visit::visit_lifetime_def - Rust -

    [−][src]Function syn::visit::visit_lifetime_def

    pub fn visit_lifetime_def<'ast, V: ?Sized>(v: &mut V, node: &'ast LifetimeDef) where
        V: Visit<'ast>, 
    \ No newline at end of file +

    Function syn::visit::visit_lifetime_def[−][src]

    pub fn visit_lifetime_def<'ast, V: ?Sized>(v: &mut V, node: &'ast LifetimeDef) where
        V: Visit<'ast>, 
    + \ No newline at end of file diff --git a/syn/visit/fn.visit_lit.html b/syn/visit/fn.visit_lit.html index 7230198..dac9385 100644 --- a/syn/visit/fn.visit_lit.html +++ b/syn/visit/fn.visit_lit.html @@ -1,4 +1,5 @@ -syn::visit::visit_lit - Rust +syn::visit::visit_lit - Rust -

    [−][src]Function syn::visit::visit_lit

    pub fn visit_lit<'ast, V: ?Sized>(v: &mut V, node: &'ast Lit) where
        V: Visit<'ast>, 
    \ No newline at end of file +

    Function syn::visit::visit_lit[−][src]

    pub fn visit_lit<'ast, V: ?Sized>(v: &mut V, node: &'ast Lit) where
        V: Visit<'ast>, 
    + \ No newline at end of file diff --git a/syn/visit/fn.visit_lit_bool.html b/syn/visit/fn.visit_lit_bool.html index 86cd41b..1d9b19c 100644 --- a/syn/visit/fn.visit_lit_bool.html +++ b/syn/visit/fn.visit_lit_bool.html @@ -1,4 +1,5 @@ -syn::visit::visit_lit_bool - Rust +syn::visit::visit_lit_bool - Rust -

    [−][src]Function syn::visit::visit_lit_bool

    pub fn visit_lit_bool<'ast, V: ?Sized>(v: &mut V, node: &'ast LitBool) where
        V: Visit<'ast>, 
    \ No newline at end of file +

    Function syn::visit::visit_lit_bool[−][src]

    pub fn visit_lit_bool<'ast, V: ?Sized>(v: &mut V, node: &'ast LitBool) where
        V: Visit<'ast>, 
    + \ No newline at end of file diff --git a/syn/visit/fn.visit_lit_byte.html b/syn/visit/fn.visit_lit_byte.html index 0b42237..e2c9306 100644 --- a/syn/visit/fn.visit_lit_byte.html +++ b/syn/visit/fn.visit_lit_byte.html @@ -1,4 +1,5 @@ -syn::visit::visit_lit_byte - Rust +syn::visit::visit_lit_byte - Rust -

    [−][src]Function syn::visit::visit_lit_byte

    pub fn visit_lit_byte<'ast, V: ?Sized>(v: &mut V, node: &'ast LitByte) where
        V: Visit<'ast>, 
    \ No newline at end of file +

    Function syn::visit::visit_lit_byte[−][src]

    pub fn visit_lit_byte<'ast, V: ?Sized>(v: &mut V, node: &'ast LitByte) where
        V: Visit<'ast>, 
    + \ No newline at end of file diff --git a/syn/visit/fn.visit_lit_byte_str.html b/syn/visit/fn.visit_lit_byte_str.html index 38577ef..ece6c57 100644 --- a/syn/visit/fn.visit_lit_byte_str.html +++ b/syn/visit/fn.visit_lit_byte_str.html @@ -1,4 +1,5 @@ -syn::visit::visit_lit_byte_str - Rust +syn::visit::visit_lit_byte_str - Rust -

    [−][src]Function syn::visit::visit_lit_byte_str

    pub fn visit_lit_byte_str<'ast, V: ?Sized>(v: &mut V, node: &'ast LitByteStr) where
        V: Visit<'ast>, 
    \ No newline at end of file +

    Function syn::visit::visit_lit_byte_str[−][src]

    pub fn visit_lit_byte_str<'ast, V: ?Sized>(v: &mut V, node: &'ast LitByteStr) where
        V: Visit<'ast>, 
    + \ No newline at end of file diff --git a/syn/visit/fn.visit_lit_char.html b/syn/visit/fn.visit_lit_char.html index b87b9df..eaf51cb 100644 --- a/syn/visit/fn.visit_lit_char.html +++ b/syn/visit/fn.visit_lit_char.html @@ -1,4 +1,5 @@ -syn::visit::visit_lit_char - Rust +syn::visit::visit_lit_char - Rust -

    [−][src]Function syn::visit::visit_lit_char

    pub fn visit_lit_char<'ast, V: ?Sized>(v: &mut V, node: &'ast LitChar) where
        V: Visit<'ast>, 
    \ No newline at end of file +

    Function syn::visit::visit_lit_char[−][src]

    pub fn visit_lit_char<'ast, V: ?Sized>(v: &mut V, node: &'ast LitChar) where
        V: Visit<'ast>, 
    + \ No newline at end of file diff --git a/syn/visit/fn.visit_lit_float.html b/syn/visit/fn.visit_lit_float.html index 715c3f0..86776ce 100644 --- a/syn/visit/fn.visit_lit_float.html +++ b/syn/visit/fn.visit_lit_float.html @@ -1,4 +1,5 @@ -syn::visit::visit_lit_float - Rust +syn::visit::visit_lit_float - Rust -

    [−][src]Function syn::visit::visit_lit_float

    pub fn visit_lit_float<'ast, V: ?Sized>(v: &mut V, node: &'ast LitFloat) where
        V: Visit<'ast>, 
    \ No newline at end of file +

    Function syn::visit::visit_lit_float[−][src]

    pub fn visit_lit_float<'ast, V: ?Sized>(v: &mut V, node: &'ast LitFloat) where
        V: Visit<'ast>, 
    + \ No newline at end of file diff --git a/syn/visit/fn.visit_lit_int.html b/syn/visit/fn.visit_lit_int.html index 74fa15a..5606bb3 100644 --- a/syn/visit/fn.visit_lit_int.html +++ b/syn/visit/fn.visit_lit_int.html @@ -1,4 +1,5 @@ -syn::visit::visit_lit_int - Rust +syn::visit::visit_lit_int - Rust -

    [−][src]Function syn::visit::visit_lit_int

    pub fn visit_lit_int<'ast, V: ?Sized>(v: &mut V, node: &'ast LitInt) where
        V: Visit<'ast>, 
    \ No newline at end of file +

    Function syn::visit::visit_lit_int[−][src]

    pub fn visit_lit_int<'ast, V: ?Sized>(v: &mut V, node: &'ast LitInt) where
        V: Visit<'ast>, 
    + \ No newline at end of file diff --git a/syn/visit/fn.visit_lit_str.html b/syn/visit/fn.visit_lit_str.html index 620653d..8867ad8 100644 --- a/syn/visit/fn.visit_lit_str.html +++ b/syn/visit/fn.visit_lit_str.html @@ -1,4 +1,5 @@ -syn::visit::visit_lit_str - Rust +syn::visit::visit_lit_str - Rust -

    [−][src]Function syn::visit::visit_lit_str

    pub fn visit_lit_str<'ast, V: ?Sized>(v: &mut V, node: &'ast LitStr) where
        V: Visit<'ast>, 
    \ No newline at end of file +

    Function syn::visit::visit_lit_str[−][src]

    pub fn visit_lit_str<'ast, V: ?Sized>(v: &mut V, node: &'ast LitStr) where
        V: Visit<'ast>, 
    + \ No newline at end of file diff --git a/syn/visit/fn.visit_macro.html b/syn/visit/fn.visit_macro.html index 08f44ef..f9edf95 100644 --- a/syn/visit/fn.visit_macro.html +++ b/syn/visit/fn.visit_macro.html @@ -1,4 +1,5 @@ -syn::visit::visit_macro - Rust +syn::visit::visit_macro - Rust -

    [−][src]Function syn::visit::visit_macro

    pub fn visit_macro<'ast, V: ?Sized>(v: &mut V, node: &'ast Macro) where
        V: Visit<'ast>, 
    \ No newline at end of file +

    Function syn::visit::visit_macro[−][src]

    pub fn visit_macro<'ast, V: ?Sized>(v: &mut V, node: &'ast Macro) where
        V: Visit<'ast>, 
    + \ No newline at end of file diff --git a/syn/visit/fn.visit_macro_delimiter.html b/syn/visit/fn.visit_macro_delimiter.html index c4d36a0..c244039 100644 --- a/syn/visit/fn.visit_macro_delimiter.html +++ b/syn/visit/fn.visit_macro_delimiter.html @@ -1,4 +1,5 @@ -syn::visit::visit_macro_delimiter - Rust +syn::visit::visit_macro_delimiter - Rust -

    [−][src]Function syn::visit::visit_macro_delimiter

    pub fn visit_macro_delimiter<'ast, V: ?Sized>(
        v: &mut V, 
        node: &'ast MacroDelimiter
    ) where
        V: Visit<'ast>, 
    \ No newline at end of file +

    Function syn::visit::visit_macro_delimiter[−][src]

    pub fn visit_macro_delimiter<'ast, V: ?Sized>(
        v: &mut V, 
        node: &'ast MacroDelimiter
    ) where
        V: Visit<'ast>, 
    + \ No newline at end of file diff --git a/syn/visit/fn.visit_member.html b/syn/visit/fn.visit_member.html index 6f5f6bc..3686cfe 100644 --- a/syn/visit/fn.visit_member.html +++ b/syn/visit/fn.visit_member.html @@ -1,4 +1,5 @@ -syn::visit::visit_member - Rust +syn::visit::visit_member - Rust -

    [−][src]Function syn::visit::visit_member

    pub fn visit_member<'ast, V: ?Sized>(v: &mut V, node: &'ast Member) where
        V: Visit<'ast>, 
    \ No newline at end of file +

    Function syn::visit::visit_member[−][src]

    pub fn visit_member<'ast, V: ?Sized>(v: &mut V, node: &'ast Member) where
        V: Visit<'ast>, 
    + \ No newline at end of file diff --git a/syn/visit/fn.visit_meta.html b/syn/visit/fn.visit_meta.html index 3620973..1e5a79a 100644 --- a/syn/visit/fn.visit_meta.html +++ b/syn/visit/fn.visit_meta.html @@ -1,4 +1,5 @@ -syn::visit::visit_meta - Rust +syn::visit::visit_meta - Rust -

    [−][src]Function syn::visit::visit_meta

    pub fn visit_meta<'ast, V: ?Sized>(v: &mut V, node: &'ast Meta) where
        V: Visit<'ast>, 
    \ No newline at end of file +

    Function syn::visit::visit_meta[−][src]

    pub fn visit_meta<'ast, V: ?Sized>(v: &mut V, node: &'ast Meta) where
        V: Visit<'ast>, 
    + \ No newline at end of file diff --git a/syn/visit/fn.visit_meta_list.html b/syn/visit/fn.visit_meta_list.html index 8ef14a5..728776c 100644 --- a/syn/visit/fn.visit_meta_list.html +++ b/syn/visit/fn.visit_meta_list.html @@ -1,4 +1,5 @@ -syn::visit::visit_meta_list - Rust +syn::visit::visit_meta_list - Rust -

    [−][src]Function syn::visit::visit_meta_list

    pub fn visit_meta_list<'ast, V: ?Sized>(v: &mut V, node: &'ast MetaList) where
        V: Visit<'ast>, 
    \ No newline at end of file +

    Function syn::visit::visit_meta_list[−][src]

    pub fn visit_meta_list<'ast, V: ?Sized>(v: &mut V, node: &'ast MetaList) where
        V: Visit<'ast>, 
    + \ No newline at end of file diff --git a/syn/visit/fn.visit_meta_name_value.html b/syn/visit/fn.visit_meta_name_value.html index de63dba..aa16bd4 100644 --- a/syn/visit/fn.visit_meta_name_value.html +++ b/syn/visit/fn.visit_meta_name_value.html @@ -1,4 +1,5 @@ -syn::visit::visit_meta_name_value - Rust +syn::visit::visit_meta_name_value - Rust -

    [−][src]Function syn::visit::visit_meta_name_value

    pub fn visit_meta_name_value<'ast, V: ?Sized>(
        v: &mut V, 
        node: &'ast MetaNameValue
    ) where
        V: Visit<'ast>, 
    \ No newline at end of file +

    Function syn::visit::visit_meta_name_value[−][src]

    pub fn visit_meta_name_value<'ast, V: ?Sized>(
        v: &mut V, 
        node: &'ast MetaNameValue
    ) where
        V: Visit<'ast>, 
    + \ No newline at end of file diff --git a/syn/visit/fn.visit_nested_meta.html b/syn/visit/fn.visit_nested_meta.html index 0b6a820..0cce5e8 100644 --- a/syn/visit/fn.visit_nested_meta.html +++ b/syn/visit/fn.visit_nested_meta.html @@ -1,4 +1,5 @@ -syn::visit::visit_nested_meta - Rust +syn::visit::visit_nested_meta - Rust -

    [−][src]Function syn::visit::visit_nested_meta

    pub fn visit_nested_meta<'ast, V: ?Sized>(v: &mut V, node: &'ast NestedMeta) where
        V: Visit<'ast>, 
    \ No newline at end of file +

    Function syn::visit::visit_nested_meta[−][src]

    pub fn visit_nested_meta<'ast, V: ?Sized>(v: &mut V, node: &'ast NestedMeta) where
        V: Visit<'ast>, 
    + \ No newline at end of file diff --git a/syn/visit/fn.visit_parenthesized_generic_arguments.html b/syn/visit/fn.visit_parenthesized_generic_arguments.html index fa411e3..945f444 100644 --- a/syn/visit/fn.visit_parenthesized_generic_arguments.html +++ b/syn/visit/fn.visit_parenthesized_generic_arguments.html @@ -1,4 +1,5 @@ -syn::visit::visit_parenthesized_generic_arguments - Rust +syn::visit::visit_parenthesized_generic_arguments - Rust -

    [−][src]Function syn::visit::visit_parenthesized_generic_arguments

    pub fn visit_parenthesized_generic_arguments<'ast, V: ?Sized>(
        v: &mut V, 
        node: &'ast ParenthesizedGenericArguments
    ) where
        V: Visit<'ast>, 
    \ No newline at end of file +

    Function syn::visit::visit_parenthesized_generic_arguments[−][src]

    pub fn visit_parenthesized_generic_arguments<'ast, V: ?Sized>(
        v: &mut V, 
        node: &'ast ParenthesizedGenericArguments
    ) where
        V: Visit<'ast>, 
    + \ No newline at end of file diff --git a/syn/visit/fn.visit_path.html b/syn/visit/fn.visit_path.html index 546ec2b..7da5f06 100644 --- a/syn/visit/fn.visit_path.html +++ b/syn/visit/fn.visit_path.html @@ -1,4 +1,5 @@ -syn::visit::visit_path - Rust +syn::visit::visit_path - Rust -

    [−][src]Function syn::visit::visit_path

    pub fn visit_path<'ast, V: ?Sized>(v: &mut V, node: &'ast Path) where
        V: Visit<'ast>, 
    \ No newline at end of file +

    Function syn::visit::visit_path[−][src]

    pub fn visit_path<'ast, V: ?Sized>(v: &mut V, node: &'ast Path) where
        V: Visit<'ast>, 
    + \ No newline at end of file diff --git a/syn/visit/fn.visit_path_arguments.html b/syn/visit/fn.visit_path_arguments.html index 313b6ec..8ffb4b8 100644 --- a/syn/visit/fn.visit_path_arguments.html +++ b/syn/visit/fn.visit_path_arguments.html @@ -1,4 +1,5 @@ -syn::visit::visit_path_arguments - Rust +syn::visit::visit_path_arguments - Rust -

    [−][src]Function syn::visit::visit_path_arguments

    pub fn visit_path_arguments<'ast, V: ?Sized>(
        v: &mut V, 
        node: &'ast PathArguments
    ) where
        V: Visit<'ast>, 
    \ No newline at end of file +

    Function syn::visit::visit_path_arguments[−][src]

    pub fn visit_path_arguments<'ast, V: ?Sized>(
        v: &mut V, 
        node: &'ast PathArguments
    ) where
        V: Visit<'ast>, 
    + \ No newline at end of file diff --git a/syn/visit/fn.visit_path_segment.html b/syn/visit/fn.visit_path_segment.html index b9e635d..6b126b6 100644 --- a/syn/visit/fn.visit_path_segment.html +++ b/syn/visit/fn.visit_path_segment.html @@ -1,4 +1,5 @@ -syn::visit::visit_path_segment - Rust +syn::visit::visit_path_segment - Rust -

    [−][src]Function syn::visit::visit_path_segment

    pub fn visit_path_segment<'ast, V: ?Sized>(v: &mut V, node: &'ast PathSegment) where
        V: Visit<'ast>, 
    \ No newline at end of file +

    Function syn::visit::visit_path_segment[−][src]

    pub fn visit_path_segment<'ast, V: ?Sized>(v: &mut V, node: &'ast PathSegment) where
        V: Visit<'ast>, 
    + \ No newline at end of file diff --git a/syn/visit/fn.visit_predicate_eq.html b/syn/visit/fn.visit_predicate_eq.html index 9f5b53f..68fe77f 100644 --- a/syn/visit/fn.visit_predicate_eq.html +++ b/syn/visit/fn.visit_predicate_eq.html @@ -1,4 +1,5 @@ -syn::visit::visit_predicate_eq - Rust +syn::visit::visit_predicate_eq - Rust -

    [−][src]Function syn::visit::visit_predicate_eq

    pub fn visit_predicate_eq<'ast, V: ?Sized>(v: &mut V, node: &'ast PredicateEq) where
        V: Visit<'ast>, 
    \ No newline at end of file +

    Function syn::visit::visit_predicate_eq[−][src]

    pub fn visit_predicate_eq<'ast, V: ?Sized>(v: &mut V, node: &'ast PredicateEq) where
        V: Visit<'ast>, 
    + \ No newline at end of file diff --git a/syn/visit/fn.visit_predicate_lifetime.html b/syn/visit/fn.visit_predicate_lifetime.html index 64506bb..d3b9f83 100644 --- a/syn/visit/fn.visit_predicate_lifetime.html +++ b/syn/visit/fn.visit_predicate_lifetime.html @@ -1,4 +1,5 @@ -syn::visit::visit_predicate_lifetime - Rust +syn::visit::visit_predicate_lifetime - Rust -

    [−][src]Function syn::visit::visit_predicate_lifetime

    pub fn visit_predicate_lifetime<'ast, V: ?Sized>(
        v: &mut V, 
        node: &'ast PredicateLifetime
    ) where
        V: Visit<'ast>, 
    \ No newline at end of file +

    Function syn::visit::visit_predicate_lifetime[−][src]

    pub fn visit_predicate_lifetime<'ast, V: ?Sized>(
        v: &mut V, 
        node: &'ast PredicateLifetime
    ) where
        V: Visit<'ast>, 
    + \ No newline at end of file diff --git a/syn/visit/fn.visit_predicate_type.html b/syn/visit/fn.visit_predicate_type.html index 60d9812..63cff50 100644 --- a/syn/visit/fn.visit_predicate_type.html +++ b/syn/visit/fn.visit_predicate_type.html @@ -1,4 +1,5 @@ -syn::visit::visit_predicate_type - Rust +syn::visit::visit_predicate_type - Rust -

    [−][src]Function syn::visit::visit_predicate_type

    pub fn visit_predicate_type<'ast, V: ?Sized>(
        v: &mut V, 
        node: &'ast PredicateType
    ) where
        V: Visit<'ast>, 
    \ No newline at end of file +

    Function syn::visit::visit_predicate_type[−][src]

    pub fn visit_predicate_type<'ast, V: ?Sized>(
        v: &mut V, 
        node: &'ast PredicateType
    ) where
        V: Visit<'ast>, 
    + \ No newline at end of file diff --git a/syn/visit/fn.visit_qself.html b/syn/visit/fn.visit_qself.html index ff073f2..81b2ffd 100644 --- a/syn/visit/fn.visit_qself.html +++ b/syn/visit/fn.visit_qself.html @@ -1,4 +1,5 @@ -syn::visit::visit_qself - Rust +syn::visit::visit_qself - Rust -

    [−][src]Function syn::visit::visit_qself

    pub fn visit_qself<'ast, V: ?Sized>(v: &mut V, node: &'ast QSelf) where
        V: Visit<'ast>, 
    \ No newline at end of file +

    Function syn::visit::visit_qself[−][src]

    pub fn visit_qself<'ast, V: ?Sized>(v: &mut V, node: &'ast QSelf) where
        V: Visit<'ast>, 
    + \ No newline at end of file diff --git a/syn/visit/fn.visit_return_type.html b/syn/visit/fn.visit_return_type.html index 26ea08c..2c506fd 100644 --- a/syn/visit/fn.visit_return_type.html +++ b/syn/visit/fn.visit_return_type.html @@ -1,4 +1,5 @@ -syn::visit::visit_return_type - Rust +syn::visit::visit_return_type - Rust -

    [−][src]Function syn::visit::visit_return_type

    pub fn visit_return_type<'ast, V: ?Sized>(v: &mut V, node: &'ast ReturnType) where
        V: Visit<'ast>, 
    \ No newline at end of file +

    Function syn::visit::visit_return_type[−][src]

    pub fn visit_return_type<'ast, V: ?Sized>(v: &mut V, node: &'ast ReturnType) where
        V: Visit<'ast>, 
    + \ No newline at end of file diff --git a/syn/visit/fn.visit_span.html b/syn/visit/fn.visit_span.html index 19bc824..0bb21ab 100644 --- a/syn/visit/fn.visit_span.html +++ b/syn/visit/fn.visit_span.html @@ -1,4 +1,5 @@ -syn::visit::visit_span - Rust +syn::visit::visit_span - Rust -

    [−][src]Function syn::visit::visit_span

    pub fn visit_span<'ast, V: ?Sized>(v: &mut V, node: &Span) where
        V: Visit<'ast>, 
    \ No newline at end of file +

    Function syn::visit::visit_span[−][src]

    pub fn visit_span<'ast, V: ?Sized>(v: &mut V, node: &Span) where
        V: Visit<'ast>, 
    + \ No newline at end of file diff --git a/syn/visit/fn.visit_trait_bound.html b/syn/visit/fn.visit_trait_bound.html index 8d83c6c..e8f44e3 100644 --- a/syn/visit/fn.visit_trait_bound.html +++ b/syn/visit/fn.visit_trait_bound.html @@ -1,4 +1,5 @@ -syn::visit::visit_trait_bound - Rust +syn::visit::visit_trait_bound - Rust -

    [−][src]Function syn::visit::visit_trait_bound

    pub fn visit_trait_bound<'ast, V: ?Sized>(v: &mut V, node: &'ast TraitBound) where
        V: Visit<'ast>, 
    \ No newline at end of file +

    Function syn::visit::visit_trait_bound[−][src]

    pub fn visit_trait_bound<'ast, V: ?Sized>(v: &mut V, node: &'ast TraitBound) where
        V: Visit<'ast>, 
    + \ No newline at end of file diff --git a/syn/visit/fn.visit_trait_bound_modifier.html b/syn/visit/fn.visit_trait_bound_modifier.html index 1a4b3f0..ea5526d 100644 --- a/syn/visit/fn.visit_trait_bound_modifier.html +++ b/syn/visit/fn.visit_trait_bound_modifier.html @@ -1,4 +1,5 @@ -syn::visit::visit_trait_bound_modifier - Rust +syn::visit::visit_trait_bound_modifier - Rust -

    [−][src]Function syn::visit::visit_trait_bound_modifier

    pub fn visit_trait_bound_modifier<'ast, V: ?Sized>(
        v: &mut V, 
        node: &'ast TraitBoundModifier
    ) where
        V: Visit<'ast>, 
    \ No newline at end of file +

    Function syn::visit::visit_trait_bound_modifier[−][src]

    pub fn visit_trait_bound_modifier<'ast, V: ?Sized>(
        v: &mut V, 
        node: &'ast TraitBoundModifier
    ) where
        V: Visit<'ast>, 
    + \ No newline at end of file diff --git a/syn/visit/fn.visit_type.html b/syn/visit/fn.visit_type.html index 7ece62f..b205a85 100644 --- a/syn/visit/fn.visit_type.html +++ b/syn/visit/fn.visit_type.html @@ -1,4 +1,5 @@ -syn::visit::visit_type - Rust +syn::visit::visit_type - Rust -

    [−][src]Function syn::visit::visit_type

    pub fn visit_type<'ast, V: ?Sized>(v: &mut V, node: &'ast Type) where
        V: Visit<'ast>, 
    \ No newline at end of file +

    Function syn::visit::visit_type[−][src]

    pub fn visit_type<'ast, V: ?Sized>(v: &mut V, node: &'ast Type) where
        V: Visit<'ast>, 
    + \ No newline at end of file diff --git a/syn/visit/fn.visit_type_array.html b/syn/visit/fn.visit_type_array.html index 2f4b827..982fe10 100644 --- a/syn/visit/fn.visit_type_array.html +++ b/syn/visit/fn.visit_type_array.html @@ -1,4 +1,5 @@ -syn::visit::visit_type_array - Rust +syn::visit::visit_type_array - Rust -

    [−][src]Function syn::visit::visit_type_array

    pub fn visit_type_array<'ast, V: ?Sized>(v: &mut V, node: &'ast TypeArray) where
        V: Visit<'ast>, 
    \ No newline at end of file +

    Function syn::visit::visit_type_array[−][src]

    pub fn visit_type_array<'ast, V: ?Sized>(v: &mut V, node: &'ast TypeArray) where
        V: Visit<'ast>, 
    + \ No newline at end of file diff --git a/syn/visit/fn.visit_type_bare_fn.html b/syn/visit/fn.visit_type_bare_fn.html index 87ef24d..c61a414 100644 --- a/syn/visit/fn.visit_type_bare_fn.html +++ b/syn/visit/fn.visit_type_bare_fn.html @@ -1,4 +1,5 @@ -syn::visit::visit_type_bare_fn - Rust +syn::visit::visit_type_bare_fn - Rust -

    [−][src]Function syn::visit::visit_type_bare_fn

    pub fn visit_type_bare_fn<'ast, V: ?Sized>(v: &mut V, node: &'ast TypeBareFn) where
        V: Visit<'ast>, 
    \ No newline at end of file +

    Function syn::visit::visit_type_bare_fn[−][src]

    pub fn visit_type_bare_fn<'ast, V: ?Sized>(v: &mut V, node: &'ast TypeBareFn) where
        V: Visit<'ast>, 
    + \ No newline at end of file diff --git a/syn/visit/fn.visit_type_group.html b/syn/visit/fn.visit_type_group.html index a1551fc..9d2ae8b 100644 --- a/syn/visit/fn.visit_type_group.html +++ b/syn/visit/fn.visit_type_group.html @@ -1,4 +1,5 @@ -syn::visit::visit_type_group - Rust +syn::visit::visit_type_group - Rust -

    [−][src]Function syn::visit::visit_type_group

    pub fn visit_type_group<'ast, V: ?Sized>(v: &mut V, node: &'ast TypeGroup) where
        V: Visit<'ast>, 
    \ No newline at end of file +

    Function syn::visit::visit_type_group[−][src]

    pub fn visit_type_group<'ast, V: ?Sized>(v: &mut V, node: &'ast TypeGroup) where
        V: Visit<'ast>, 
    + \ No newline at end of file diff --git a/syn/visit/fn.visit_type_impl_trait.html b/syn/visit/fn.visit_type_impl_trait.html index 14b6f95..33c4459 100644 --- a/syn/visit/fn.visit_type_impl_trait.html +++ b/syn/visit/fn.visit_type_impl_trait.html @@ -1,4 +1,5 @@ -syn::visit::visit_type_impl_trait - Rust +syn::visit::visit_type_impl_trait - Rust -

    [−][src]Function syn::visit::visit_type_impl_trait

    pub fn visit_type_impl_trait<'ast, V: ?Sized>(
        v: &mut V, 
        node: &'ast TypeImplTrait
    ) where
        V: Visit<'ast>, 
    \ No newline at end of file +

    Function syn::visit::visit_type_impl_trait[−][src]

    pub fn visit_type_impl_trait<'ast, V: ?Sized>(
        v: &mut V, 
        node: &'ast TypeImplTrait
    ) where
        V: Visit<'ast>, 
    + \ No newline at end of file diff --git a/syn/visit/fn.visit_type_infer.html b/syn/visit/fn.visit_type_infer.html index 6cccf03..793e489 100644 --- a/syn/visit/fn.visit_type_infer.html +++ b/syn/visit/fn.visit_type_infer.html @@ -1,4 +1,5 @@ -syn::visit::visit_type_infer - Rust +syn::visit::visit_type_infer - Rust -

    [−][src]Function syn::visit::visit_type_infer

    pub fn visit_type_infer<'ast, V: ?Sized>(v: &mut V, node: &'ast TypeInfer) where
        V: Visit<'ast>, 
    \ No newline at end of file +

    Function syn::visit::visit_type_infer[−][src]

    pub fn visit_type_infer<'ast, V: ?Sized>(v: &mut V, node: &'ast TypeInfer) where
        V: Visit<'ast>, 
    + \ No newline at end of file diff --git a/syn/visit/fn.visit_type_macro.html b/syn/visit/fn.visit_type_macro.html index 2fe742a..c60d2ea 100644 --- a/syn/visit/fn.visit_type_macro.html +++ b/syn/visit/fn.visit_type_macro.html @@ -1,4 +1,5 @@ -syn::visit::visit_type_macro - Rust +syn::visit::visit_type_macro - Rust -

    [−][src]Function syn::visit::visit_type_macro

    pub fn visit_type_macro<'ast, V: ?Sized>(v: &mut V, node: &'ast TypeMacro) where
        V: Visit<'ast>, 
    \ No newline at end of file +

    Function syn::visit::visit_type_macro[−][src]

    pub fn visit_type_macro<'ast, V: ?Sized>(v: &mut V, node: &'ast TypeMacro) where
        V: Visit<'ast>, 
    + \ No newline at end of file diff --git a/syn/visit/fn.visit_type_never.html b/syn/visit/fn.visit_type_never.html index 8fb1b2f..ee837ee 100644 --- a/syn/visit/fn.visit_type_never.html +++ b/syn/visit/fn.visit_type_never.html @@ -1,4 +1,5 @@ -syn::visit::visit_type_never - Rust +syn::visit::visit_type_never - Rust -

    [−][src]Function syn::visit::visit_type_never

    pub fn visit_type_never<'ast, V: ?Sized>(v: &mut V, node: &'ast TypeNever) where
        V: Visit<'ast>, 
    \ No newline at end of file +

    Function syn::visit::visit_type_never[−][src]

    pub fn visit_type_never<'ast, V: ?Sized>(v: &mut V, node: &'ast TypeNever) where
        V: Visit<'ast>, 
    + \ No newline at end of file diff --git a/syn/visit/fn.visit_type_param.html b/syn/visit/fn.visit_type_param.html index c8587a3..c144d70 100644 --- a/syn/visit/fn.visit_type_param.html +++ b/syn/visit/fn.visit_type_param.html @@ -1,4 +1,5 @@ -syn::visit::visit_type_param - Rust +syn::visit::visit_type_param - Rust -

    [−][src]Function syn::visit::visit_type_param

    pub fn visit_type_param<'ast, V: ?Sized>(v: &mut V, node: &'ast TypeParam) where
        V: Visit<'ast>, 
    \ No newline at end of file +

    Function syn::visit::visit_type_param[−][src]

    pub fn visit_type_param<'ast, V: ?Sized>(v: &mut V, node: &'ast TypeParam) where
        V: Visit<'ast>, 
    + \ No newline at end of file diff --git a/syn/visit/fn.visit_type_param_bound.html b/syn/visit/fn.visit_type_param_bound.html index 218c315..5cf48b3 100644 --- a/syn/visit/fn.visit_type_param_bound.html +++ b/syn/visit/fn.visit_type_param_bound.html @@ -1,4 +1,5 @@ -syn::visit::visit_type_param_bound - Rust +syn::visit::visit_type_param_bound - Rust -

    [−][src]Function syn::visit::visit_type_param_bound

    pub fn visit_type_param_bound<'ast, V: ?Sized>(
        v: &mut V, 
        node: &'ast TypeParamBound
    ) where
        V: Visit<'ast>, 
    \ No newline at end of file +

    Function syn::visit::visit_type_param_bound[−][src]

    pub fn visit_type_param_bound<'ast, V: ?Sized>(
        v: &mut V, 
        node: &'ast TypeParamBound
    ) where
        V: Visit<'ast>, 
    + \ No newline at end of file diff --git a/syn/visit/fn.visit_type_paren.html b/syn/visit/fn.visit_type_paren.html index e2dec16..9f326f2 100644 --- a/syn/visit/fn.visit_type_paren.html +++ b/syn/visit/fn.visit_type_paren.html @@ -1,4 +1,5 @@ -syn::visit::visit_type_paren - Rust +syn::visit::visit_type_paren - Rust -

    [−][src]Function syn::visit::visit_type_paren

    pub fn visit_type_paren<'ast, V: ?Sized>(v: &mut V, node: &'ast TypeParen) where
        V: Visit<'ast>, 
    \ No newline at end of file +

    Function syn::visit::visit_type_paren[−][src]

    pub fn visit_type_paren<'ast, V: ?Sized>(v: &mut V, node: &'ast TypeParen) where
        V: Visit<'ast>, 
    + \ No newline at end of file diff --git a/syn/visit/fn.visit_type_path.html b/syn/visit/fn.visit_type_path.html index 3918be4..0eb8571 100644 --- a/syn/visit/fn.visit_type_path.html +++ b/syn/visit/fn.visit_type_path.html @@ -1,4 +1,5 @@ -syn::visit::visit_type_path - Rust +syn::visit::visit_type_path - Rust -

    [−][src]Function syn::visit::visit_type_path

    pub fn visit_type_path<'ast, V: ?Sized>(v: &mut V, node: &'ast TypePath) where
        V: Visit<'ast>, 
    \ No newline at end of file +

    Function syn::visit::visit_type_path[−][src]

    pub fn visit_type_path<'ast, V: ?Sized>(v: &mut V, node: &'ast TypePath) where
        V: Visit<'ast>, 
    + \ No newline at end of file diff --git a/syn/visit/fn.visit_type_ptr.html b/syn/visit/fn.visit_type_ptr.html index 7ab2dde..b56ee26 100644 --- a/syn/visit/fn.visit_type_ptr.html +++ b/syn/visit/fn.visit_type_ptr.html @@ -1,4 +1,5 @@ -syn::visit::visit_type_ptr - Rust +syn::visit::visit_type_ptr - Rust -

    [−][src]Function syn::visit::visit_type_ptr

    pub fn visit_type_ptr<'ast, V: ?Sized>(v: &mut V, node: &'ast TypePtr) where
        V: Visit<'ast>, 
    \ No newline at end of file +

    Function syn::visit::visit_type_ptr[−][src]

    pub fn visit_type_ptr<'ast, V: ?Sized>(v: &mut V, node: &'ast TypePtr) where
        V: Visit<'ast>, 
    + \ No newline at end of file diff --git a/syn/visit/fn.visit_type_reference.html b/syn/visit/fn.visit_type_reference.html index a84af57..1b12093 100644 --- a/syn/visit/fn.visit_type_reference.html +++ b/syn/visit/fn.visit_type_reference.html @@ -1,4 +1,5 @@ -syn::visit::visit_type_reference - Rust +syn::visit::visit_type_reference - Rust -

    [−][src]Function syn::visit::visit_type_reference

    pub fn visit_type_reference<'ast, V: ?Sized>(
        v: &mut V, 
        node: &'ast TypeReference
    ) where
        V: Visit<'ast>, 
    \ No newline at end of file +

    Function syn::visit::visit_type_reference[−][src]

    pub fn visit_type_reference<'ast, V: ?Sized>(
        v: &mut V, 
        node: &'ast TypeReference
    ) where
        V: Visit<'ast>, 
    + \ No newline at end of file diff --git a/syn/visit/fn.visit_type_slice.html b/syn/visit/fn.visit_type_slice.html index 906ec34..992efff 100644 --- a/syn/visit/fn.visit_type_slice.html +++ b/syn/visit/fn.visit_type_slice.html @@ -1,4 +1,5 @@ -syn::visit::visit_type_slice - Rust +syn::visit::visit_type_slice - Rust -

    [−][src]Function syn::visit::visit_type_slice

    pub fn visit_type_slice<'ast, V: ?Sized>(v: &mut V, node: &'ast TypeSlice) where
        V: Visit<'ast>, 
    \ No newline at end of file +

    Function syn::visit::visit_type_slice[−][src]

    pub fn visit_type_slice<'ast, V: ?Sized>(v: &mut V, node: &'ast TypeSlice) where
        V: Visit<'ast>, 
    + \ No newline at end of file diff --git a/syn/visit/fn.visit_type_trait_object.html b/syn/visit/fn.visit_type_trait_object.html index d7ca86b..405d88c 100644 --- a/syn/visit/fn.visit_type_trait_object.html +++ b/syn/visit/fn.visit_type_trait_object.html @@ -1,4 +1,5 @@ -syn::visit::visit_type_trait_object - Rust +syn::visit::visit_type_trait_object - Rust -

    [−][src]Function syn::visit::visit_type_trait_object

    pub fn visit_type_trait_object<'ast, V: ?Sized>(
        v: &mut V, 
        node: &'ast TypeTraitObject
    ) where
        V: Visit<'ast>, 
    \ No newline at end of file +

    Function syn::visit::visit_type_trait_object[−][src]

    pub fn visit_type_trait_object<'ast, V: ?Sized>(
        v: &mut V, 
        node: &'ast TypeTraitObject
    ) where
        V: Visit<'ast>, 
    + \ No newline at end of file diff --git a/syn/visit/fn.visit_type_tuple.html b/syn/visit/fn.visit_type_tuple.html index 2958620..359b416 100644 --- a/syn/visit/fn.visit_type_tuple.html +++ b/syn/visit/fn.visit_type_tuple.html @@ -1,4 +1,5 @@ -syn::visit::visit_type_tuple - Rust +syn::visit::visit_type_tuple - Rust -

    [−][src]Function syn::visit::visit_type_tuple

    pub fn visit_type_tuple<'ast, V: ?Sized>(v: &mut V, node: &'ast TypeTuple) where
        V: Visit<'ast>, 
    \ No newline at end of file +

    Function syn::visit::visit_type_tuple[−][src]

    pub fn visit_type_tuple<'ast, V: ?Sized>(v: &mut V, node: &'ast TypeTuple) where
        V: Visit<'ast>, 
    + \ No newline at end of file diff --git a/syn/visit/fn.visit_un_op.html b/syn/visit/fn.visit_un_op.html index 7e21ea9..a23fab5 100644 --- a/syn/visit/fn.visit_un_op.html +++ b/syn/visit/fn.visit_un_op.html @@ -1,4 +1,5 @@ -syn::visit::visit_un_op - Rust +syn::visit::visit_un_op - Rust -

    [−][src]Function syn::visit::visit_un_op

    pub fn visit_un_op<'ast, V: ?Sized>(v: &mut V, node: &'ast UnOp) where
        V: Visit<'ast>, 
    \ No newline at end of file +

    Function syn::visit::visit_un_op[−][src]

    pub fn visit_un_op<'ast, V: ?Sized>(v: &mut V, node: &'ast UnOp) where
        V: Visit<'ast>, 
    + \ No newline at end of file diff --git a/syn/visit/fn.visit_variadic.html b/syn/visit/fn.visit_variadic.html index 8618641..001f40f 100644 --- a/syn/visit/fn.visit_variadic.html +++ b/syn/visit/fn.visit_variadic.html @@ -1,4 +1,5 @@ -syn::visit::visit_variadic - Rust +syn::visit::visit_variadic - Rust -

    [−][src]Function syn::visit::visit_variadic

    pub fn visit_variadic<'ast, V: ?Sized>(v: &mut V, node: &'ast Variadic) where
        V: Visit<'ast>, 
    \ No newline at end of file +

    Function syn::visit::visit_variadic[−][src]

    pub fn visit_variadic<'ast, V: ?Sized>(v: &mut V, node: &'ast Variadic) where
        V: Visit<'ast>, 
    + \ No newline at end of file diff --git a/syn/visit/fn.visit_variant.html b/syn/visit/fn.visit_variant.html index 934ce9f..ea97ed6 100644 --- a/syn/visit/fn.visit_variant.html +++ b/syn/visit/fn.visit_variant.html @@ -1,4 +1,5 @@ -syn::visit::visit_variant - Rust +syn::visit::visit_variant - Rust -

    [−][src]Function syn::visit::visit_variant

    pub fn visit_variant<'ast, V: ?Sized>(v: &mut V, node: &'ast Variant) where
        V: Visit<'ast>, 
    \ No newline at end of file +

    Function syn::visit::visit_variant[−][src]

    pub fn visit_variant<'ast, V: ?Sized>(v: &mut V, node: &'ast Variant) where
        V: Visit<'ast>, 
    + \ No newline at end of file diff --git a/syn/visit/fn.visit_vis_crate.html b/syn/visit/fn.visit_vis_crate.html index a4c5c7f..1547447 100644 --- a/syn/visit/fn.visit_vis_crate.html +++ b/syn/visit/fn.visit_vis_crate.html @@ -1,4 +1,5 @@ -syn::visit::visit_vis_crate - Rust +syn::visit::visit_vis_crate - Rust -

    [−][src]Function syn::visit::visit_vis_crate

    pub fn visit_vis_crate<'ast, V: ?Sized>(v: &mut V, node: &'ast VisCrate) where
        V: Visit<'ast>, 
    \ No newline at end of file +

    Function syn::visit::visit_vis_crate[−][src]

    pub fn visit_vis_crate<'ast, V: ?Sized>(v: &mut V, node: &'ast VisCrate) where
        V: Visit<'ast>, 
    + \ No newline at end of file diff --git a/syn/visit/fn.visit_vis_public.html b/syn/visit/fn.visit_vis_public.html index 571a1d5..6faaf84 100644 --- a/syn/visit/fn.visit_vis_public.html +++ b/syn/visit/fn.visit_vis_public.html @@ -1,4 +1,5 @@ -syn::visit::visit_vis_public - Rust +syn::visit::visit_vis_public - Rust -

    [−][src]Function syn::visit::visit_vis_public

    pub fn visit_vis_public<'ast, V: ?Sized>(v: &mut V, node: &'ast VisPublic) where
        V: Visit<'ast>, 
    \ No newline at end of file +

    Function syn::visit::visit_vis_public[−][src]

    pub fn visit_vis_public<'ast, V: ?Sized>(v: &mut V, node: &'ast VisPublic) where
        V: Visit<'ast>, 
    + \ No newline at end of file diff --git a/syn/visit/fn.visit_vis_restricted.html b/syn/visit/fn.visit_vis_restricted.html index 782b774..edcb752 100644 --- a/syn/visit/fn.visit_vis_restricted.html +++ b/syn/visit/fn.visit_vis_restricted.html @@ -1,4 +1,5 @@ -syn::visit::visit_vis_restricted - Rust +syn::visit::visit_vis_restricted - Rust -

    [−][src]Function syn::visit::visit_vis_restricted

    pub fn visit_vis_restricted<'ast, V: ?Sized>(
        v: &mut V, 
        node: &'ast VisRestricted
    ) where
        V: Visit<'ast>, 
    \ No newline at end of file +

    Function syn::visit::visit_vis_restricted[−][src]

    pub fn visit_vis_restricted<'ast, V: ?Sized>(
        v: &mut V, 
        node: &'ast VisRestricted
    ) where
        V: Visit<'ast>, 
    + \ No newline at end of file diff --git a/syn/visit/fn.visit_visibility.html b/syn/visit/fn.visit_visibility.html index c07821a..1281595 100644 --- a/syn/visit/fn.visit_visibility.html +++ b/syn/visit/fn.visit_visibility.html @@ -1,4 +1,5 @@ -syn::visit::visit_visibility - Rust +syn::visit::visit_visibility - Rust -

    [−][src]Function syn::visit::visit_visibility

    pub fn visit_visibility<'ast, V: ?Sized>(v: &mut V, node: &'ast Visibility) where
        V: Visit<'ast>, 
    \ No newline at end of file +

    Function syn::visit::visit_visibility[−][src]

    pub fn visit_visibility<'ast, V: ?Sized>(v: &mut V, node: &'ast Visibility) where
        V: Visit<'ast>, 
    + \ No newline at end of file diff --git a/syn/visit/fn.visit_where_clause.html b/syn/visit/fn.visit_where_clause.html index 52996c8..9532981 100644 --- a/syn/visit/fn.visit_where_clause.html +++ b/syn/visit/fn.visit_where_clause.html @@ -1,4 +1,5 @@ -syn::visit::visit_where_clause - Rust +syn::visit::visit_where_clause - Rust -

    [−][src]Function syn::visit::visit_where_clause

    pub fn visit_where_clause<'ast, V: ?Sized>(v: &mut V, node: &'ast WhereClause) where
        V: Visit<'ast>, 
    \ No newline at end of file +

    Function syn::visit::visit_where_clause[−][src]

    pub fn visit_where_clause<'ast, V: ?Sized>(v: &mut V, node: &'ast WhereClause) where
        V: Visit<'ast>, 
    + \ No newline at end of file diff --git a/syn/visit/fn.visit_where_predicate.html b/syn/visit/fn.visit_where_predicate.html index 93d37c4..4578918 100644 --- a/syn/visit/fn.visit_where_predicate.html +++ b/syn/visit/fn.visit_where_predicate.html @@ -1,4 +1,5 @@ -syn::visit::visit_where_predicate - Rust +syn::visit::visit_where_predicate - Rust -

    [−][src]Function syn::visit::visit_where_predicate

    pub fn visit_where_predicate<'ast, V: ?Sized>(
        v: &mut V, 
        node: &'ast WherePredicate
    ) where
        V: Visit<'ast>, 
    \ No newline at end of file +

    Function syn::visit::visit_where_predicate[−][src]

    pub fn visit_where_predicate<'ast, V: ?Sized>(
        v: &mut V, 
        node: &'ast WherePredicate
    ) where
        V: Visit<'ast>, 
    + \ No newline at end of file diff --git a/syn/visit/index.html b/syn/visit/index.html index c1998f3..6925553 100644 --- a/syn/visit/index.html +++ b/syn/visit/index.html @@ -1,7 +1,7 @@ -syn::visit - Rust +syn::visit - Rust -

    [−][src]Module syn::visit

    Syntax tree traversal to walk a shared borrow of a syntax tree.

    +

    Module syn::visit[−][src]

    Syntax tree traversal to walk a shared borrow of a syntax tree.

    Each method of the Visit trait is a hook that can be overridden to customize the behavior when visiting the corresponding type of node. By default, every method recursively visits the substructure of the input @@ -104,4 +104,5 @@ hold on to references into the syntax tree.

    Traits

    Visit

    Syntax tree traversal to walk a shared borrow of a syntax tree.

    Functions

    -
    visit_abi
    visit_angle_bracketed_generic_arguments
    visit_attr_style
    visit_attribute
    visit_bare_fn_arg
    visit_bin_op
    visit_binding
    visit_bound_lifetimes
    visit_const_param
    visit_constraint
    visit_data
    visit_data_enum
    visit_data_struct
    visit_data_union
    visit_derive_input
    visit_expr
    visit_expr_binary
    visit_expr_call
    visit_expr_cast
    visit_expr_field
    visit_expr_index
    visit_expr_lit
    visit_expr_paren
    visit_expr_path
    visit_expr_unary
    visit_field
    visit_fields
    visit_fields_named
    visit_fields_unnamed
    visit_generic_argument
    visit_generic_param
    visit_generics
    visit_ident
    visit_index
    visit_lifetime
    visit_lifetime_def
    visit_lit
    visit_lit_bool
    visit_lit_byte
    visit_lit_byte_str
    visit_lit_char
    visit_lit_float
    visit_lit_int
    visit_lit_str
    visit_macro
    visit_macro_delimiter
    visit_member
    visit_meta
    visit_meta_list
    visit_meta_name_value
    visit_nested_meta
    visit_parenthesized_generic_arguments
    visit_path
    visit_path_arguments
    visit_path_segment
    visit_predicate_eq
    visit_predicate_lifetime
    visit_predicate_type
    visit_qself
    visit_return_type
    visit_span
    visit_trait_bound
    visit_trait_bound_modifier
    visit_type
    visit_type_array
    visit_type_bare_fn
    visit_type_group
    visit_type_impl_trait
    visit_type_infer
    visit_type_macro
    visit_type_never
    visit_type_param
    visit_type_param_bound
    visit_type_paren
    visit_type_path
    visit_type_ptr
    visit_type_reference
    visit_type_slice
    visit_type_trait_object
    visit_type_tuple
    visit_un_op
    visit_variadic
    visit_variant
    visit_vis_crate
    visit_vis_public
    visit_vis_restricted
    visit_visibility
    visit_where_clause
    visit_where_predicate
    \ No newline at end of file +
    visit_abi
    visit_angle_bracketed_generic_arguments
    visit_attr_style
    visit_attribute
    visit_bare_fn_arg
    visit_bin_op
    visit_binding
    visit_bound_lifetimes
    visit_const_param
    visit_constraint
    visit_data
    visit_data_enum
    visit_data_struct
    visit_data_union
    visit_derive_input
    visit_expr
    visit_expr_binary
    visit_expr_call
    visit_expr_cast
    visit_expr_field
    visit_expr_index
    visit_expr_lit
    visit_expr_paren
    visit_expr_path
    visit_expr_unary
    visit_field
    visit_fields
    visit_fields_named
    visit_fields_unnamed
    visit_generic_argument
    visit_generic_param
    visit_generics
    visit_ident
    visit_index
    visit_lifetime
    visit_lifetime_def
    visit_lit
    visit_lit_bool
    visit_lit_byte
    visit_lit_byte_str
    visit_lit_char
    visit_lit_float
    visit_lit_int
    visit_lit_str
    visit_macro
    visit_macro_delimiter
    visit_member
    visit_meta
    visit_meta_list
    visit_meta_name_value
    visit_nested_meta
    visit_parenthesized_generic_arguments
    visit_path
    visit_path_arguments
    visit_path_segment
    visit_predicate_eq
    visit_predicate_lifetime
    visit_predicate_type
    visit_qself
    visit_return_type
    visit_span
    visit_trait_bound
    visit_trait_bound_modifier
    visit_type
    visit_type_array
    visit_type_bare_fn
    visit_type_group
    visit_type_impl_trait
    visit_type_infer
    visit_type_macro
    visit_type_never
    visit_type_param
    visit_type_param_bound
    visit_type_paren
    visit_type_path
    visit_type_ptr
    visit_type_reference
    visit_type_slice
    visit_type_trait_object
    visit_type_tuple
    visit_un_op
    visit_variadic
    visit_variant
    visit_vis_crate
    visit_vis_public
    visit_vis_restricted
    visit_visibility
    visit_where_clause
    visit_where_predicate
    + \ No newline at end of file diff --git a/syn/visit/trait.Visit.html b/syn/visit/trait.Visit.html index 7922fc4..208ade2 100644 --- a/syn/visit/trait.Visit.html +++ b/syn/visit/trait.Visit.html @@ -1,7 +1,7 @@ -syn::visit::Visit - Rust +syn::visit::Visit - Rust -

    [−][src]Trait syn::visit::Visit

    pub trait Visit<'ast> {
+
    Trait syn::visit::Visit[−][src]
    pub trait Visit<'ast> {
     fn visit_abi(&mut self, i: &'ast Abi) { ... }
 
        fn visit_angle_bracketed_generic_arguments(
            &mut self, 
            i: &'ast AngleBracketedGenericArguments
        ) { ... }
 
        fn visit_attr_style(&mut self, i: &'ast AttrStyle) { ... }
@@ -94,4 +94,5 @@
 }
    Syntax tree traversal to walk a shared borrow of a syntax tree.
    
 
    See the module documentation for details.
    
 
    This trait is available only if Syn is built with the "visit" feature.
    
-
    Provided methods
    fn visit_abi(&mut self, i: &'ast Abi)[src]
    fn visit_angle_bracketed_generic_arguments(
        &mut self, 
        i: &'ast AngleBracketedGenericArguments
    )    [src]
    fn visit_attr_style(&mut self, i: &'ast AttrStyle)[src]
    fn visit_attribute(&mut self, i: &'ast Attribute)[src]
    fn visit_bare_fn_arg(&mut self, i: &'ast BareFnArg)[src]
    fn visit_bin_op(&mut self, i: &'ast BinOp)[src]
    fn visit_binding(&mut self, i: &'ast Binding)[src]
    fn visit_bound_lifetimes(&mut self, i: &'ast BoundLifetimes)[src]
    fn visit_const_param(&mut self, i: &'ast ConstParam)[src]
    fn visit_constraint(&mut self, i: &'ast Constraint)[src]
    fn visit_data(&mut self, i: &'ast Data)[src]
    fn visit_data_enum(&mut self, i: &'ast DataEnum)[src]
    fn visit_data_struct(&mut self, i: &'ast DataStruct)[src]
    fn visit_data_union(&mut self, i: &'ast DataUnion)[src]
    fn visit_derive_input(&mut self, i: &'ast DeriveInput)[src]
    fn visit_expr(&mut self, i: &'ast Expr)[src]
    fn visit_expr_binary(&mut self, i: &'ast ExprBinary)[src]
    fn visit_expr_call(&mut self, i: &'ast ExprCall)[src]
    fn visit_expr_cast(&mut self, i: &'ast ExprCast)[src]
    fn visit_expr_field(&mut self, i: &'ast ExprField)[src]
    fn visit_expr_index(&mut self, i: &'ast ExprIndex)[src]
    fn visit_expr_lit(&mut self, i: &'ast ExprLit)[src]
    fn visit_expr_paren(&mut self, i: &'ast ExprParen)[src]
    fn visit_expr_path(&mut self, i: &'ast ExprPath)[src]
    fn visit_expr_unary(&mut self, i: &'ast ExprUnary)[src]
    fn visit_field(&mut self, i: &'ast Field)[src]
    fn visit_fields(&mut self, i: &'ast Fields)[src]
    fn visit_fields_named(&mut self, i: &'ast FieldsNamed)[src]
    fn visit_fields_unnamed(&mut self, i: &'ast FieldsUnnamed)[src]
    fn visit_generic_argument(&mut self, i: &'ast GenericArgument)[src]
    fn visit_generic_param(&mut self, i: &'ast GenericParam)[src]
    fn visit_generics(&mut self, i: &'ast Generics)[src]
    fn visit_ident(&mut self, i: &'ast Ident)[src]
    fn visit_index(&mut self, i: &'ast Index)[src]
    fn visit_lifetime(&mut self, i: &'ast Lifetime)[src]
    fn visit_lifetime_def(&mut self, i: &'ast LifetimeDef)[src]
    fn visit_lit(&mut self, i: &'ast Lit)[src]
    fn visit_lit_bool(&mut self, i: &'ast LitBool)[src]
    fn visit_lit_byte(&mut self, i: &'ast LitByte)[src]
    fn visit_lit_byte_str(&mut self, i: &'ast LitByteStr)[src]
    fn visit_lit_char(&mut self, i: &'ast LitChar)[src]
    fn visit_lit_float(&mut self, i: &'ast LitFloat)[src]
    fn visit_lit_int(&mut self, i: &'ast LitInt)[src]
    fn visit_lit_str(&mut self, i: &'ast LitStr)[src]
    fn visit_macro(&mut self, i: &'ast Macro)[src]
    fn visit_macro_delimiter(&mut self, i: &'ast MacroDelimiter)[src]
    fn visit_member(&mut self, i: &'ast Member)[src]
    fn visit_meta(&mut self, i: &'ast Meta)[src]
    fn visit_meta_list(&mut self, i: &'ast MetaList)[src]
    fn visit_meta_name_value(&mut self, i: &'ast MetaNameValue)[src]
    fn visit_nested_meta(&mut self, i: &'ast NestedMeta)[src]
    fn visit_parenthesized_generic_arguments(
        &mut self, 
        i: &'ast ParenthesizedGenericArguments
    )    [src]
    fn visit_path(&mut self, i: &'ast Path)[src]
    fn visit_path_arguments(&mut self, i: &'ast PathArguments)[src]
    fn visit_path_segment(&mut self, i: &'ast PathSegment)[src]
    fn visit_predicate_eq(&mut self, i: &'ast PredicateEq)[src]
    fn visit_predicate_lifetime(&mut self, i: &'ast PredicateLifetime)[src]
    fn visit_predicate_type(&mut self, i: &'ast PredicateType)[src]
    fn visit_qself(&mut self, i: &'ast QSelf)[src]
    fn visit_return_type(&mut self, i: &'ast ReturnType)[src]
    fn visit_span(&mut self, i: &Span)[src]
    fn visit_trait_bound(&mut self, i: &'ast TraitBound)[src]
    fn visit_trait_bound_modifier(&mut self, i: &'ast TraitBoundModifier)[src]
    fn visit_type(&mut self, i: &'ast Type)[src]
    fn visit_type_array(&mut self, i: &'ast TypeArray)[src]
    fn visit_type_bare_fn(&mut self, i: &'ast TypeBareFn)[src]
    fn visit_type_group(&mut self, i: &'ast TypeGroup)[src]
    fn visit_type_impl_trait(&mut self, i: &'ast TypeImplTrait)[src]
    fn visit_type_infer(&mut self, i: &'ast TypeInfer)[src]
    fn visit_type_macro(&mut self, i: &'ast TypeMacro)[src]
    fn visit_type_never(&mut self, i: &'ast TypeNever)[src]
    fn visit_type_param(&mut self, i: &'ast TypeParam)[src]
    fn visit_type_param_bound(&mut self, i: &'ast TypeParamBound)[src]
    fn visit_type_paren(&mut self, i: &'ast TypeParen)[src]
    fn visit_type_path(&mut self, i: &'ast TypePath)[src]
    fn visit_type_ptr(&mut self, i: &'ast TypePtr)[src]
    fn visit_type_reference(&mut self, i: &'ast TypeReference)[src]
    fn visit_type_slice(&mut self, i: &'ast TypeSlice)[src]
    fn visit_type_trait_object(&mut self, i: &'ast TypeTraitObject)[src]
    fn visit_type_tuple(&mut self, i: &'ast TypeTuple)[src]
    fn visit_un_op(&mut self, i: &'ast UnOp)[src]
    fn visit_variadic(&mut self, i: &'ast Variadic)[src]
    fn visit_variant(&mut self, i: &'ast Variant)[src]
    fn visit_vis_crate(&mut self, i: &'ast VisCrate)[src]
    fn visit_vis_public(&mut self, i: &'ast VisPublic)[src]
    fn visit_vis_restricted(&mut self, i: &'ast VisRestricted)[src]
    fn visit_visibility(&mut self, i: &'ast Visibility)[src]
    fn visit_where_clause(&mut self, i: &'ast WhereClause)[src]
    fn visit_where_predicate(&mut self, i: &'ast WherePredicate)[src]
    Loading content...
    Implementors
    Loading content...
    
\ No newline at end of file
+

    Provided methods

    fn visit_abi(&mut self, i: &'ast Abi)[src]

    fn visit_angle_bracketed_generic_arguments(
        &mut self,
        i: &'ast AngleBracketedGenericArguments
    )    [src]

    fn visit_attr_style(&mut self, i: &'ast AttrStyle)[src]

    fn visit_attribute(&mut self, i: &'ast Attribute)[src]

    fn visit_bare_fn_arg(&mut self, i: &'ast BareFnArg)[src]

    fn visit_bin_op(&mut self, i: &'ast BinOp)[src]

    fn visit_binding(&mut self, i: &'ast Binding)[src]

    fn visit_bound_lifetimes(&mut self, i: &'ast BoundLifetimes)[src]

    fn visit_const_param(&mut self, i: &'ast ConstParam)[src]

    fn visit_constraint(&mut self, i: &'ast Constraint)[src]

    fn visit_data(&mut self, i: &'ast Data)[src]

    fn visit_data_enum(&mut self, i: &'ast DataEnum)[src]

    fn visit_data_struct(&mut self, i: &'ast DataStruct)[src]

    fn visit_data_union(&mut self, i: &'ast DataUnion)[src]

    fn visit_derive_input(&mut self, i: &'ast DeriveInput)[src]

    fn visit_expr(&mut self, i: &'ast Expr)[src]

    fn visit_expr_binary(&mut self, i: &'ast ExprBinary)[src]

    fn visit_expr_call(&mut self, i: &'ast ExprCall)[src]

    fn visit_expr_cast(&mut self, i: &'ast ExprCast)[src]

    fn visit_expr_field(&mut self, i: &'ast ExprField)[src]

    fn visit_expr_index(&mut self, i: &'ast ExprIndex)[src]

    fn visit_expr_lit(&mut self, i: &'ast ExprLit)[src]

    fn visit_expr_paren(&mut self, i: &'ast ExprParen)[src]

    fn visit_expr_path(&mut self, i: &'ast ExprPath)[src]

    fn visit_expr_unary(&mut self, i: &'ast ExprUnary)[src]

    fn visit_field(&mut self, i: &'ast Field)[src]

    fn visit_fields(&mut self, i: &'ast Fields)[src]

    fn visit_fields_named(&mut self, i: &'ast FieldsNamed)[src]

    fn visit_fields_unnamed(&mut self, i: &'ast FieldsUnnamed)[src]

    fn visit_generic_argument(&mut self, i: &'ast GenericArgument)[src]

    fn visit_generic_param(&mut self, i: &'ast GenericParam)[src]

    fn visit_generics(&mut self, i: &'ast Generics)[src]

    fn visit_ident(&mut self, i: &'ast Ident)[src]

    fn visit_index(&mut self, i: &'ast Index)[src]

    fn visit_lifetime(&mut self, i: &'ast Lifetime)[src]

    fn visit_lifetime_def(&mut self, i: &'ast LifetimeDef)[src]

    fn visit_lit(&mut self, i: &'ast Lit)[src]

    fn visit_lit_bool(&mut self, i: &'ast LitBool)[src]

    fn visit_lit_byte(&mut self, i: &'ast LitByte)[src]

    fn visit_lit_byte_str(&mut self, i: &'ast LitByteStr)[src]

    fn visit_lit_char(&mut self, i: &'ast LitChar)[src]

    fn visit_lit_float(&mut self, i: &'ast LitFloat)[src]

    fn visit_lit_int(&mut self, i: &'ast LitInt)[src]

    fn visit_lit_str(&mut self, i: &'ast LitStr)[src]

    fn visit_macro(&mut self, i: &'ast Macro)[src]

    fn visit_macro_delimiter(&mut self, i: &'ast MacroDelimiter)[src]

    fn visit_member(&mut self, i: &'ast Member)[src]

    fn visit_meta(&mut self, i: &'ast Meta)[src]

    fn visit_meta_list(&mut self, i: &'ast MetaList)[src]

    fn visit_meta_name_value(&mut self, i: &'ast MetaNameValue)[src]

    fn visit_nested_meta(&mut self, i: &'ast NestedMeta)[src]

    fn visit_parenthesized_generic_arguments(
        &mut self,
        i: &'ast ParenthesizedGenericArguments
    )    [src]

    fn visit_path(&mut self, i: &'ast Path)[src]

    fn visit_path_arguments(&mut self, i: &'ast PathArguments)[src]

    fn visit_path_segment(&mut self, i: &'ast PathSegment)[src]

    fn visit_predicate_eq(&mut self, i: &'ast PredicateEq)[src]

    fn visit_predicate_lifetime(&mut self, i: &'ast PredicateLifetime)[src]

    fn visit_predicate_type(&mut self, i: &'ast PredicateType)[src]

    fn visit_qself(&mut self, i: &'ast QSelf)[src]

    fn visit_return_type(&mut self, i: &'ast ReturnType)[src]

    fn visit_span(&mut self, i: &Span)[src]

    fn visit_trait_bound(&mut self, i: &'ast TraitBound)[src]

    fn visit_trait_bound_modifier(&mut self, i: &'ast TraitBoundModifier)[src]

    fn visit_type(&mut self, i: &'ast Type)[src]

    fn visit_type_array(&mut self, i: &'ast TypeArray)[src]

    fn visit_type_bare_fn(&mut self, i: &'ast TypeBareFn)[src]

    fn visit_type_group(&mut self, i: &'ast TypeGroup)[src]

    fn visit_type_impl_trait(&mut self, i: &'ast TypeImplTrait)[src]

    fn visit_type_infer(&mut self, i: &'ast TypeInfer)[src]

    fn visit_type_macro(&mut self, i: &'ast TypeMacro)[src]

    fn visit_type_never(&mut self, i: &'ast TypeNever)[src]

    fn visit_type_param(&mut self, i: &'ast TypeParam)[src]

    fn visit_type_param_bound(&mut self, i: &'ast TypeParamBound)[src]

    fn visit_type_paren(&mut self, i: &'ast TypeParen)[src]

    fn visit_type_path(&mut self, i: &'ast TypePath)[src]

    fn visit_type_ptr(&mut self, i: &'ast TypePtr)[src]

    fn visit_type_reference(&mut self, i: &'ast TypeReference)[src]

    fn visit_type_slice(&mut self, i: &'ast TypeSlice)[src]

    fn visit_type_trait_object(&mut self, i: &'ast TypeTraitObject)[src]

    fn visit_type_tuple(&mut self, i: &'ast TypeTuple)[src]

    fn visit_un_op(&mut self, i: &'ast UnOp)[src]

    fn visit_variadic(&mut self, i: &'ast Variadic)[src]

    fn visit_variant(&mut self, i: &'ast Variant)[src]

    fn visit_vis_crate(&mut self, i: &'ast VisCrate)[src]

    fn visit_vis_public(&mut self, i: &'ast VisPublic)[src]

    fn visit_vis_restricted(&mut self, i: &'ast VisRestricted)[src]

    fn visit_visibility(&mut self, i: &'ast Visibility)[src]

    fn visit_where_clause(&mut self, i: &'ast WhereClause)[src]

    fn visit_where_predicate(&mut self, i: &'ast WherePredicate)[src]

    Loading content...

    Implementors

    Loading content...
    + \ No newline at end of file diff --git a/synstructure/all.html b/synstructure/all.html index 0575629..682615c 100644 --- a/synstructure/all.html +++ b/synstructure/all.html @@ -1,6 +1,7 @@ -List of all items in this crate +List of all items in this crate -

    [−] +

    List of all items[−] - List of all items

    Structs

    Enums

    Traits

    Macros

    Functions

    \ No newline at end of file +

    Structs

    Enums

    Traits

    Macros

    Functions

    + \ No newline at end of file diff --git a/synstructure/enum.AddBounds.html b/synstructure/enum.AddBounds.html index 71ef0e4..6184bc6 100644 --- a/synstructure/enum.AddBounds.html +++ b/synstructure/enum.AddBounds.html @@ -1,7 +1,7 @@ -synstructure::AddBounds - Rust +synstructure::AddBounds - Rust -

    [−][src]Enum synstructure::AddBounds

    pub enum AddBounds {
+
    Enum synstructure::AddBounds[−][src]
    pub enum AddBounds {
     Both,
     Fields,
     Generics,
@@ -15,24 +15,25 @@
 
    Generics
    Generics only
    
 
    None
    None
    
 
    Trait Implementations
    impl Clone for AddBounds[src]
    impl Copy for AddBounds[src]
    impl Debug for AddBounds[src]
    impl Eq for AddBounds[src]
    impl Hash for AddBounds[src]
    impl PartialEq<AddBounds> for AddBounds[src]
    impl StructuralEq for AddBounds[src]
    impl StructuralPartialEq for AddBounds[src]
    Auto Trait Implementations
    Blanket Implementations
    impl<T> Any for T where
        T: 'static + ?Sized,     [src]
    impl<T> Borrow<T> for T where
        T: ?Sized,     [src]
    impl<T> BorrowMut<T> for T where
        T: ?Sized,     [src]
    impl<T> From<T> for T[src]
    impl<T, U> Into<U> for T where
        U: From<T>,     [src]
    impl<T> ToOwned for T where
        T: Clone,     [src]
    type Owned = T
    The resulting type after obtaining ownership.
    
-
    impl StructuralEq for AddBounds[src]
    impl StructuralPartialEq for AddBounds[src]
    Auto Trait Implementations
    Blanket Implementations
    impl<T> Any for T where
        T: 'static + ?Sized,     [src]
    impl<T> Borrow<T> for T where
        T: ?Sized,     [src]
    impl<T> BorrowMut<T> for T where
        T: ?Sized,     [src]
    impl<T> From<T> for T[src]
    impl<T, U> Into<U> for T where
        U: From<T>,     [src]
    impl<T> ToOwned for T where
        T: Clone,     [src]
    type Owned = T
    The resulting type after obtaining ownership.
    
+
    impl<T, U> TryFrom<U> for T where
        U: Into<T>,     [src]
    type Error = Infallible
    The type returned in the event of a conversion error.
    
-
    impl<T, U> TryInto<U> for T where
        U: TryFrom<T>,     [src]
    type Error = <U as TryFrom<T>>::Error
    The type returned in the event of a conversion error.
    
-
    
\ No newline at end of file
+

    impl<T, U> TryFrom<U> for T where
        U: Into<T>,     [src]

    type Error = Infallible

    The type returned in the event of a conversion error.

    +

    impl<T, U> TryInto<U> for T where
        U: TryFrom<T>,     [src]

    type Error = <U as TryFrom<T>>::Error

    The type returned in the event of a conversion error.

    +
    + \ No newline at end of file diff --git a/synstructure/enum.BindStyle.html b/synstructure/enum.BindStyle.html index 8cd2d7c..50ac606 100644 --- a/synstructure/enum.BindStyle.html +++ b/synstructure/enum.BindStyle.html @@ -1,7 +1,7 @@ -synstructure::BindStyle - Rust +synstructure::BindStyle - Rust -

    [−][src]Enum synstructure::BindStyle

    pub enum BindStyle {
+
    Enum synstructure::BindStyle[−][src]
    pub enum BindStyle {
     Move,
     MoveMut,
     Ref,
@@ -14,29 +14,30 @@
 
    Ref
    ref x
    
 
    RefMut
    ref mut x
    
 
    Trait Implementations
    impl Clone for BindStyle[src]
    impl Copy for BindStyle[src]
    impl Debug for BindStyle[src]
    impl Eq for BindStyle[src]
    impl Hash for BindStyle[src]
    impl PartialEq<BindStyle> for BindStyle[src]
    impl StructuralEq for BindStyle[src]
    impl StructuralPartialEq for BindStyle[src]
    impl ToTokens for BindStyle[src]
    Auto Trait Implementations
    Blanket Implementations
    impl<T> Any for T where
        T: 'static + ?Sized,     [src]
    impl<T> Borrow<T> for T where
        T: ?Sized,     [src]
    impl<T> BorrowMut<T> for T where
        T: ?Sized,     [src]
    impl<T> From<T> for T[src]
    impl<T, U> Into<U> for T where
        U: From<T>,     [src]
    impl<T> Spanned for T where
        T: Spanned + ?Sized,     [src]
    Auto Trait Implementations
    Blanket Implementations
    impl<T> Any for T where
        T: 'static + ?Sized,     [src]
    impl<T> Borrow<T> for T where
        T: ?Sized,     [src]
    impl<T> BorrowMut<T> for T where
        T: ?Sized,     [src]
    impl<T> From<T> for T[src]
    impl<T, U> Into<U> for T where
        U: From<T>,     [src]
    impl<T> Spanned for T where
        T: Spanned + ?Sized,     [src]
    impl<T> ToOwned for T where
        T: Clone,     [src]
    type Owned = T
    The resulting type after obtaining ownership.
    
-
    impl<T> ToOwned for T where
        T: Clone,     [src]
    type Owned = T
    The resulting type after obtaining ownership.
    
+
    impl<T, U> TryFrom<U> for T where
        U: Into<T>,     [src]
    type Error = Infallible
    The type returned in the event of a conversion error.
    
-
    impl<T, U> TryInto<U> for T where
        U: TryFrom<T>,     [src]
    type Error = <U as TryFrom<T>>::Error
    The type returned in the event of a conversion error.
    
-
    
\ No newline at end of file
+

    impl<T, U> TryFrom<U> for T where
        U: Into<T>,     [src]

    type Error = Infallible

    The type returned in the event of a conversion error.

    +

    impl<T, U> TryInto<U> for T where
        U: TryFrom<T>,     [src]

    type Error = <U as TryFrom<T>>::Error

    The type returned in the event of a conversion error.

    +
    + \ No newline at end of file diff --git a/synstructure/fn.unpretty_print.html b/synstructure/fn.unpretty_print.html index e176836..30580f0 100644 --- a/synstructure/fn.unpretty_print.html +++ b/synstructure/fn.unpretty_print.html @@ -1,7 +1,7 @@ -synstructure::unpretty_print - Rust +synstructure::unpretty_print - Rust -

    [−][src]Function synstructure::unpretty_print

    pub fn unpretty_print<T: Display>(ts: T) -> String

    Dumps an unpretty version of a tokenstream. Takes any type which implements +

    Function synstructure::unpretty_print[−][src]

    pub fn unpretty_print<T: Display>(ts: T) -> String

    Dumps an unpretty version of a tokenstream. Takes any type which implements Display.

    This is mostly useful for visualizing the output of a procedural macro, as it makes it marginally more readable. It is used in the implementation of @@ -44,4 +44,5 @@ const _DERIVE_krate_Trait_FOR_A : ( ; " )

    -
    \ No newline at end of file +
    + \ No newline at end of file diff --git a/synstructure/index.html b/synstructure/index.html index 302c16b..8c3b0f2 100644 --- a/synstructure/index.html +++ b/synstructure/index.html @@ -1,7 +1,7 @@ -synstructure - Rust +synstructure - Rust -

    [−][src]Crate synstructure

    This crate provides helper types for matching against enum variants, and +

    Crate synstructure[−][src]

    This crate provides helper types for matching against enum variants, and extracting bindings to each of the fields in the deriving Struct or Enum in a generic way.

    If you are writing a #[derive] which needs to perform some operation on @@ -150,19 +150,20 @@ reference to the given field, and the syn &'a Field descriptor field.

    Structure

    A wrapper around a syn::DeriveInput which provides utilities for creating custom derive trait implementations.

    -VariantAst

    This type is similar to syn's Variant type, however each of the fields +VariantAst

    This type is similar to syn’s Variant type, however each of the fields are references rather than owned. When this is used as the AST for a real variant, this struct simply borrows the fields of the syn::Variant, however this type may also be used as the sole variant for a struct.

    -VariantInfo

    A wrapper around a syn::DeriveInput's variant which provides utilities +VariantInfo

    A wrapper around a syn::DeriveInput’s variant which provides utilities for destructuring Variants with match expressions.

    Enums

    AddBounds

    Changes how bounds are added

    BindStyle

    The type of binding to use when generating a pattern.

    Traits

    MacroResult

    Helper trait describing values which may be returned by macro implementation -methods used by this crate's macros.

    +methods used by this crate’s macros.

    Functions

    unpretty_print

    Dumps an unpretty version of a tokenstream. Takes any type which implements Display.

    -
    \ No newline at end of file +
    + \ No newline at end of file diff --git a/synstructure/macro.decl_attribute.html b/synstructure/macro.decl_attribute.html index 918891e..eb254d8 100644 --- a/synstructure/macro.decl_attribute.html +++ b/synstructure/macro.decl_attribute.html @@ -1,7 +1,7 @@ -synstructure::decl_attribute - Rust +synstructure::decl_attribute - Rust -

    [−][src]Macro synstructure::decl_attribute

    +
    Macro synstructure::decl_attribute[−][src]
     macro_rules! decl_attribute {
     ([$attribute:ident] => $(#[$($attrs:tt)*])* $inner:path) => { ... };
 }
    
@@ -29,4 +29,5 @@ and pass it into the inner function.
    
 decl_attribute!([interesting] => attribute_interesting);

    This macro is available if synstructure is built with the "proc-macro" feature.

    -
    \ No newline at end of file +
    + \ No newline at end of file diff --git a/synstructure/macro.decl_derive.html b/synstructure/macro.decl_derive.html index 04bf733..8305206 100644 --- a/synstructure/macro.decl_derive.html +++ b/synstructure/macro.decl_derive.html @@ -1,7 +1,7 @@ -synstructure::decl_derive - Rust +synstructure::decl_derive - Rust -

    [−][src]Macro synstructure::decl_derive

    +
    Macro synstructure::decl_derive[−][src]
     macro_rules! decl_derive {
     ([$derives:ident $($derive_t:tt)*] => $(#[$($attrs:tt)*])* $inner:path) => { ... };
 }
    
@@ -49,4 +49,5 @@ return a type implementing synstructure::MacroResult, for example:<
 }

    This macro is available if synstructure is built with the "proc-macro" feature.

    -
    \ No newline at end of file +
    + \ No newline at end of file diff --git a/synstructure/macro.test_derive.html b/synstructure/macro.test_derive.html index e38ec85..44ef40b 100644 --- a/synstructure/macro.test_derive.html +++ b/synstructure/macro.test_derive.html @@ -1,7 +1,7 @@ -synstructure::test_derive - Rust +synstructure::test_derive - Rust -

    [−][src]Macro synstructure::test_derive

    +
    Macro synstructure::test_derive[−][src]
     macro_rules! test_derive {
     ($name:path { $($i:tt)* } expands to { $($o:tt)* }) => { ... };
     ($name:path { $($i:tt)* } expands to { $($o:tt)* } no_build) => { ... };
@@ -32,4 +32,5 @@ tests.
    
         }
     }
 }
    
-
    
\ No newline at end of file
+
    + \ No newline at end of file diff --git a/synstructure/sidebar-items.js b/synstructure/sidebar-items.js index f3a1b72..00169c9 100644 --- a/synstructure/sidebar-items.js +++ b/synstructure/sidebar-items.js @@ -1 +1 @@ -initSidebarItems({"enum":[["AddBounds","Changes how bounds are added"],["BindStyle","The type of binding to use when generating a pattern."]],"fn":[["unpretty_print","Dumps an unpretty version of a tokenstream. Takes any type which implements `Display`."]],"macro":[["decl_attribute","The `decl_attribute!` macro declares a custom attribute wrapper. It will parse the incoming `TokenStream` into a `synstructure::Structure` object, and pass it into the inner function."],["decl_derive","The `decl_derive!` macro declares a custom derive wrapper. It will parse the incoming `TokenStream` into a `synstructure::Structure` object, and pass it into the inner function."],["test_derive","Run a test on a custom derive. This macro expands both the original struct and the expansion to ensure that they compile correctly, and confirms that feeding the original struct into the named derive will produce the written output."]],"struct":[["BindingInfo","Information about a specific binding. This contains both an `Ident` reference to the given field, and the syn `&'a Field` descriptor for that field."],["Structure","A wrapper around a `syn::DeriveInput` which provides utilities for creating custom derive trait implementations."],["VariantAst","This type is similar to `syn`'s `Variant` type, however each of the fields are references rather than owned. When this is used as the AST for a real variant, this struct simply borrows the fields of the `syn::Variant`, however this type may also be used as the sole variant for a struct."],["VariantInfo","A wrapper around a `syn::DeriveInput`'s variant which provides utilities for destructuring `Variant`s with `match` expressions."]],"trait":[["MacroResult","Helper trait describing values which may be returned by macro implementation methods used by this crate's macros."]]}); \ No newline at end of file +initSidebarItems({"enum":[["AddBounds","Changes how bounds are added"],["BindStyle","The type of binding to use when generating a pattern."]],"fn":[["unpretty_print","Dumps an unpretty version of a tokenstream. Takes any type which implements `Display`."]],"macro":[["decl_attribute","The `decl_attribute!` macro declares a custom attribute wrapper. It will parse the incoming `TokenStream` into a `synstructure::Structure` object, and pass it into the inner function."],["decl_derive","The `decl_derive!` macro declares a custom derive wrapper. It will parse the incoming `TokenStream` into a `synstructure::Structure` object, and pass it into the inner function."],["test_derive","Run a test on a custom derive. This macro expands both the original struct and the expansion to ensure that they compile correctly, and confirms that feeding the original struct into the named derive will produce the written output."]],"struct":[["BindingInfo","Information about a specific binding. This contains both an `Ident` reference to the given field, and the syn `&'a Field` descriptor for that field."],["Structure","A wrapper around a `syn::DeriveInput` which provides utilities for creating custom derive trait implementations."],["VariantAst","This type is similar to `syn`’s `Variant` type, however each of the fields are references rather than owned. When this is used as the AST for a real variant, this struct simply borrows the fields of the `syn::Variant`, however this type may also be used as the sole variant for a struct."],["VariantInfo","A wrapper around a `syn::DeriveInput`’s variant which provides utilities for destructuring `Variant`s with `match` expressions."]],"trait":[["MacroResult","Helper trait describing values which may be returned by macro implementation methods used by this crate’s macros."]]}); \ No newline at end of file diff --git a/synstructure/struct.BindingInfo.html b/synstructure/struct.BindingInfo.html index 73c0d1e..5c736b2 100644 --- a/synstructure/struct.BindingInfo.html +++ b/synstructure/struct.BindingInfo.html @@ -1,7 +1,7 @@ -synstructure::BindingInfo - Rust +synstructure::BindingInfo - Rust -

    [−][src]Struct synstructure::BindingInfo

    pub struct BindingInfo<'a> {
+
    Struct synstructure::BindingInfo[−][src]
    pub struct BindingInfo<'a> {
     pub binding: Ident,
     pub style: BindStyle,
     // some fields omitted
@@ -33,7 +33,7 @@ field.
    
     }.to_string()
 );

    pub fn referenced_ty_params(&self) -> Vec<&'a Ident>[src]

    Returns a list of the type parameters which are referenced in this -field's type.

    +field’s type.

    Caveat

    If the field contains any macros in type position, all parameters will be considered bound. This is because we cannot determine which type @@ -53,29 +53,30 @@ parameters are bound by type macros.

    &[&quote::format_ident!("T")] );

    Trait Implementations

    impl<'a> Clone for BindingInfo<'a>[src]

    impl<'a> Debug for BindingInfo<'a>[src]

    impl<'a> Eq for BindingInfo<'a>[src]

    impl<'a> Hash for BindingInfo<'a>[src]

    impl<'a> PartialEq<BindingInfo<'a>> for BindingInfo<'a>[src]

    impl<'a> StructuralEq for BindingInfo<'a>[src]

    impl<'a> StructuralPartialEq for BindingInfo<'a>[src]

    impl<'a> ToTokens for BindingInfo<'a>[src]

    Auto Trait Implementations

    impl<'a> RefUnwindSafe for BindingInfo<'a>[src]

    impl<'a> !Send for BindingInfo<'a>[src]

    impl<'a> !Sync for BindingInfo<'a>[src]

    impl<'a> Unpin for BindingInfo<'a>[src]

    impl<'a> UnwindSafe for BindingInfo<'a>[src]

    Blanket Implementations

    impl<T> Any for T where
        T: 'static + ?Sized,     [src]

    impl<T> Borrow<T> for T where
        T: ?Sized,     [src]

    impl<T> BorrowMut<T> for T where
        T: ?Sized,     [src]

    impl<T> From<T> for T[src]

    impl<T, U> Into<U> for T where
        U: From<T>,     [src]

    impl<T> Spanned for T where
        T: Spanned + ?Sized,     [src]

    Auto Trait Implementations

    impl<'a> RefUnwindSafe for BindingInfo<'a>

    impl<'a> !Send for BindingInfo<'a>

    impl<'a> !Sync for BindingInfo<'a>

    impl<'a> Unpin for BindingInfo<'a>

    impl<'a> UnwindSafe for BindingInfo<'a>

    Blanket Implementations

    impl<T> Any for T where
        T: 'static + ?Sized,     [src]

    impl<T> Borrow<T> for T where
        T: ?Sized,     [src]

    impl<T> BorrowMut<T> for T where
        T: ?Sized,     [src]

    impl<T> From<T> for T[src]

    impl<T, U> Into<U> for T where
        U: From<T>,     [src]

    impl<T> Spanned for T where
        T: Spanned + ?Sized,     [src]

    impl<T> ToOwned for T where
        T: Clone,     [src]

    type Owned = T

    The resulting type after obtaining ownership.

    -

    impl<T> ToOwned for T where
        T: Clone,     [src]

    type Owned = T

    The resulting type after obtaining ownership.

    +

    impl<T, U> TryFrom<U> for T where
        U: Into<T>,     [src]

    type Error = Infallible

    The type returned in the event of a conversion error.

    -

    impl<T, U> TryInto<U> for T where
        U: TryFrom<T>,     [src]

    type Error = <U as TryFrom<T>>::Error

    The type returned in the event of a conversion error.

    -
    \ No newline at end of file +

    impl<T, U> TryFrom<U> for T where
        U: Into<T>,     [src]

    type Error = Infallible

    The type returned in the event of a conversion error.

    +

    impl<T, U> TryInto<U> for T where
        U: TryFrom<T>,     [src]

    type Error = <U as TryFrom<T>>::Error

    The type returned in the event of a conversion error.

    +
    + \ No newline at end of file diff --git a/synstructure/struct.Structure.html b/synstructure/struct.Structure.html index 0f0882f..9e69dde 100644 --- a/synstructure/struct.Structure.html +++ b/synstructure/struct.Structure.html @@ -1,7 +1,7 @@ -synstructure::Structure - Rust +synstructure::Structure - Rust -

    [−][src]Struct synstructure::Structure

    pub struct Structure<'a> { /* fields omitted */ }

    A wrapper around a syn::DeriveInput which provides utilities for creating +

    Struct synstructure::Structure[−][src]

    pub struct Structure<'a> { /* fields omitted */ }

    A wrapper around a syn::DeriveInput which provides utilities for creating custom derive trait implementations.

    Implementations

    impl<'a> Structure<'a>[src]

    pub fn new(ast: &'a DeriveInput) -> Self[src]

    Create a new Structure with the variants and fields from the passed-in DeriveInput.

    @@ -406,7 +406,7 @@ code generated by gen_impl and bound_impl.

    .to_string() );

    pub fn bound_impl<P: ToTokens, B: ToTokens>(
        &self,
        path: P,
        body: B
    ) -> TokenStream    [src]

    -

    NOTE: This methods' features are superceded by Structure::gen_impl.

    +

    NOTE: This methods’ features are superceded by Structure::gen_impl.

    Creates an impl block with the required generic type fields filled in to implement the trait path.

    @@ -415,7 +415,7 @@ referenced type parmaeters implement the trait path.

    Hygiene and Paths

    This method wraps the impl block inside of a const (see the example below). In this scope, the first segment of the passed-in path is -extern crate-ed in. If you don't want to generate that extern crate +extern crate-ed in. If you don’t want to generate that extern crate item, use a global path.

    This means that if you are implementing my_crate::Trait, you simply write s.bound_impl(quote!(my_crate::Trait), quote!(...)), and for the @@ -457,7 +457,7 @@ parameters are bound by type macros.

    }.to_string() );

    pub fn unsafe_bound_impl<P: ToTokens, B: ToTokens>(
        &self,
        path: P,
        body: B
    ) -> TokenStream    [src]

    -

    NOTE: This methods' features are superceded by Structure::gen_impl.

    +

    NOTE: This methods’ features are superceded by Structure::gen_impl.

    Creates an impl block with the required generic type fields filled in to implement the unsafe trait path.

    @@ -466,7 +466,7 @@ referenced type parmaeters implement the trait path.

    Hygiene and Paths

    This method wraps the impl block inside of a const (see the example below). In this scope, the first segment of the passed-in path is -extern crate-ed in. If you don't want to generate that extern crate +extern crate-ed in. If you don’t want to generate that extern crate item, use a global path.

    This means that if you are implementing my_crate::Trait, you simply write s.bound_impl(quote!(my_crate::Trait), quote!(...)), and for the @@ -508,7 +508,7 @@ parameters are bound by type macros.

    }.to_string() );

    pub fn unbound_impl<P: ToTokens, B: ToTokens>(
        &self,
        path: P,
        body: B
    ) -> TokenStream    [src]

    -

    NOTE: This methods' features are superceded by Structure::gen_impl.

    +

    NOTE: This methods’ features are superceded by Structure::gen_impl.

    Creates an impl block with the required generic type fields filled in to implement the trait path.

    @@ -516,7 +516,7 @@ to implement the trait path.

    Hygiene and Paths

    This method wraps the impl block inside of a const (see the example below). In this scope, the first segment of the passed-in path is -extern crate-ed in. If you don't want to generate that extern crate +extern crate-ed in. If you don’t want to generate that extern crate item, use a global path.

    This means that if you are implementing my_crate::Trait, you simply write s.bound_impl(quote!(my_crate::Trait), quote!(...)), and for the @@ -551,7 +551,7 @@ entirety of the definition, you can refer to your crate as my_crate }.to_string() );

    pub fn unsafe_unbound_impl<P: ToTokens, B: ToTokens>(
        &self,
        path: P,
        body: B
    ) -> TokenStream    [src]

    👎 Deprecated
    -

    NOTE: This methods' features are superceded by Structure::gen_impl.

    +

    NOTE: This methods’ features are superceded by Structure::gen_impl.

    Creates an impl block with the required generic type fields filled in to implement the unsafe trait path.

    @@ -559,7 +559,7 @@ to implement the unsafe trait path.

    Hygiene and Paths

    This method wraps the impl block inside of a const (see the example below). In this scope, the first segment of the passed-in path is -extern crate-ed in. If you don't want to generate that extern crate +extern crate-ed in. If you don’t want to generate that extern crate item, use a global path.

    This means that if you are implementing my_crate::Trait, you simply write s.bound_impl(quote!(my_crate::Trait), quote!(...)), and for the @@ -594,7 +594,7 @@ entirety of the definition, you can refer to your crate as my_crate }.to_string() );

    pub fn gen_impl(&self, cfg: TokenStream) -> TokenStream[src]

    Generate an impl block for the given struct. This impl block will -automatically use hygiene tricks to avoid polluting the caller's +automatically use hygiene tricks to avoid polluting the caller’s namespace, and will automatically add trait bounds for generic type parameters.

    Syntax

    @@ -658,9 +658,9 @@ to generate const _ instead.

    };

    Using the std crate

    If you are using quote!() to implement your trait, with the -proc-macro2/nightly feature, std isn't considered to be in scope for +proc-macro2/nightly feature, std isn’t considered to be in scope for your macro. This means that if you use types from std in your -procedural macro, you'll want to explicitly load it with an extern crate std;.

    +procedural macro, you’ll want to explicitly load it with an extern crate std;.

    Absolute paths

    You should generally avoid using absolute paths in your generated code, as they will resolve very differently when using the stable and nightly @@ -779,24 +779,25 @@ the original struct.

    );

    Use add_bounds to change which bounds are generated.

    Trait Implementations

    impl<'a> Clone for Structure<'a>[src]

    impl<'a> Debug for Structure<'a>[src]

    impl<'a> Eq for Structure<'a>[src]

    impl<'a> Hash for Structure<'a>[src]

    impl<'a> PartialEq<Structure<'a>> for Structure<'a>[src]

    impl<'a> StructuralEq for Structure<'a>[src]

    impl<'a> StructuralPartialEq for Structure<'a>[src]

    Auto Trait Implementations

    impl<'a> RefUnwindSafe for Structure<'a>[src]

    impl<'a> !Send for Structure<'a>[src]

    impl<'a> !Sync for Structure<'a>[src]

    impl<'a> Unpin for Structure<'a>[src]

    impl<'a> UnwindSafe for Structure<'a>[src]

    Blanket Implementations

    impl<T> Any for T where
        T: 'static + ?Sized,     [src]

    impl<T> Borrow<T> for T where
        T: ?Sized,     [src]

    impl<T> BorrowMut<T> for T where
        T: ?Sized,     [src]

    impl<T> From<T> for T[src]

    impl<T, U> Into<U> for T where
        U: From<T>,     [src]

    impl<T> ToOwned for T where
        T: Clone,     [src]

    type Owned = T

    The resulting type after obtaining ownership.

    -

    impl<'a> StructuralEq for Structure<'a>[src]

    impl<'a> StructuralPartialEq for Structure<'a>[src]

    Auto Trait Implementations

    impl<'a> RefUnwindSafe for Structure<'a>

    impl<'a> !Send for Structure<'a>

    impl<'a> !Sync for Structure<'a>

    impl<'a> Unpin for Structure<'a>

    impl<'a> UnwindSafe for Structure<'a>

    Blanket Implementations

    impl<T> Any for T where
        T: 'static + ?Sized,     [src]

    impl<T> Borrow<T> for T where
        T: ?Sized,     [src]

    impl<T> BorrowMut<T> for T where
        T: ?Sized,     [src]

    impl<T> From<T> for T[src]

    impl<T, U> Into<U> for T where
        U: From<T>,     [src]

    impl<T> ToOwned for T where
        T: Clone,     [src]

    type Owned = T

    The resulting type after obtaining ownership.

    +

    impl<T, U> TryFrom<U> for T where
        U: Into<T>,     [src]

    type Error = Infallible

    The type returned in the event of a conversion error.

    -

    impl<T, U> TryInto<U> for T where
        U: TryFrom<T>,     [src]

    type Error = <U as TryFrom<T>>::Error

    The type returned in the event of a conversion error.

    -
    \ No newline at end of file +

    impl<T, U> TryFrom<U> for T where
        U: Into<T>,     [src]

    type Error = Infallible

    The type returned in the event of a conversion error.

    +

    impl<T, U> TryInto<U> for T where
        U: TryFrom<T>,     [src]

    type Error = <U as TryFrom<T>>::Error

    The type returned in the event of a conversion error.

    +
    + \ No newline at end of file diff --git a/synstructure/struct.VariantAst.html b/synstructure/struct.VariantAst.html index a8465e4..8e01ae1 100644 --- a/synstructure/struct.VariantAst.html +++ b/synstructure/struct.VariantAst.html @@ -1,35 +1,36 @@ -synstructure::VariantAst - Rust +synstructure::VariantAst - Rust -

    [−][src]Struct synstructure::VariantAst

    pub struct VariantAst<'a> {
+
    Struct synstructure::VariantAst[−][src]
    pub struct VariantAst<'a> {
     pub attrs: &'a [Attribute],
     pub ident: &'a Ident,
     pub fields: &'a Fields,
     pub discriminant: &'a Option<(Eq, Expr)>,
-}
    This type is similar to syn's Variant type, however each of the fields
+}

    This type is similar to syn’s Variant type, however each of the fields are references rather than owned. When this is used as the AST for a real variant, this struct simply borrows the fields of the syn::Variant, however this type may also be used as the sole variant for a struct.

    Fields

    attrs: &'a [Attribute]ident: &'a Identfields: &'a Fieldsdiscriminant: &'a Option<(Eq, Expr)>

    Trait Implementations

    impl<'a> Clone for VariantAst<'a>[src]

    impl<'a> Copy for VariantAst<'a>[src]

    impl<'a> Debug for VariantAst<'a>[src]

    impl<'a> Eq for VariantAst<'a>[src]

    impl<'a> Hash for VariantAst<'a>[src]

    impl<'a> PartialEq<VariantAst<'a>> for VariantAst<'a>[src]

    impl<'a> StructuralEq for VariantAst<'a>[src]

    impl<'a> StructuralPartialEq for VariantAst<'a>[src]

    Auto Trait Implementations

    impl<'a> RefUnwindSafe for VariantAst<'a>[src]

    impl<'a> !Send for VariantAst<'a>[src]

    impl<'a> !Sync for VariantAst<'a>[src]

    impl<'a> Unpin for VariantAst<'a>[src]

    impl<'a> UnwindSafe for VariantAst<'a>[src]

    Blanket Implementations

    impl<T> Any for T where
        T: 'static + ?Sized,     [src]

    impl<T> Borrow<T> for T where
        T: ?Sized,     [src]

    impl<T> BorrowMut<T> for T where
        T: ?Sized,     [src]

    impl<T> From<T> for T[src]

    impl<T, U> Into<U> for T where
        U: From<T>,     [src]

    impl<T> ToOwned for T where
        T: Clone,     [src]

    type Owned = T

    The resulting type after obtaining ownership.

    -

    impl<'a> StructuralEq for VariantAst<'a>[src]

    impl<'a> StructuralPartialEq for VariantAst<'a>[src]

    Auto Trait Implementations

    impl<'a> RefUnwindSafe for VariantAst<'a>

    impl<'a> !Send for VariantAst<'a>

    impl<'a> !Sync for VariantAst<'a>

    impl<'a> Unpin for VariantAst<'a>

    impl<'a> UnwindSafe for VariantAst<'a>

    Blanket Implementations

    impl<T> Any for T where
        T: 'static + ?Sized,     [src]

    impl<T> Borrow<T> for T where
        T: ?Sized,     [src]

    impl<T> BorrowMut<T> for T where
        T: ?Sized,     [src]

    impl<T> From<T> for T[src]

    impl<T, U> Into<U> for T where
        U: From<T>,     [src]

    impl<T> ToOwned for T where
        T: Clone,     [src]

    type Owned = T

    The resulting type after obtaining ownership.

    +

    impl<T, U> TryFrom<U> for T where
        U: Into<T>,     [src]

    type Error = Infallible

    The type returned in the event of a conversion error.

    -

    impl<T, U> TryInto<U> for T where
        U: TryFrom<T>,     [src]

    type Error = <U as TryFrom<T>>::Error

    The type returned in the event of a conversion error.

    -
    \ No newline at end of file +

    impl<T, U> TryFrom<U> for T where
        U: Into<T>,     [src]

    type Error = Infallible

    The type returned in the event of a conversion error.

    +

    impl<T, U> TryInto<U> for T where
        U: TryFrom<T>,     [src]

    type Error = <U as TryFrom<T>>::Error

    The type returned in the event of a conversion error.

    +
    + \ No newline at end of file diff --git a/synstructure/struct.VariantInfo.html b/synstructure/struct.VariantInfo.html index c6dc80c..545750b 100644 --- a/synstructure/struct.VariantInfo.html +++ b/synstructure/struct.VariantInfo.html @@ -1,10 +1,10 @@ -synstructure::VariantInfo - Rust +synstructure::VariantInfo - Rust -

    [−][src]Struct synstructure::VariantInfo

    pub struct VariantInfo<'a> {
+
    Struct synstructure::VariantInfo[−][src]
    pub struct VariantInfo<'a> {
     pub prefix: Option<&'a Ident>,
     // some fields omitted
-}
    A wrapper around a syn::DeriveInput's variant which provides utilities
+}

    A wrapper around a syn::DeriveInput’s variant which provides utilities for destructuring Variants with match expressions.

    Fields

    prefix: Option<&'a Ident>

    Implementations

    impl<'a> VariantInfo<'a>[src]

    pub fn bindings(&self) -> &[BindingInfo<'a>][src]

    Returns a slice of the bindings in this Variant.

    @@ -205,7 +205,7 @@ increasing number.

    }.to_string() );

    pub fn referenced_ty_params(&self) -> Vec<&'a Ident>[src]

    Returns a list of the type parameters which are referenced in this -field's type.

    +field’s type.

    Caveat

    If the field contains any macros in type position, all parameters will be considered bound. This is because we cannot determine which type @@ -225,24 +225,25 @@ parameters are bound by type macros.

    &[&quote::format_ident!("T")] );

    Trait Implementations

    impl<'a> Clone for VariantInfo<'a>[src]

    impl<'a> Debug for VariantInfo<'a>[src]

    impl<'a> Eq for VariantInfo<'a>[src]

    impl<'a> Hash for VariantInfo<'a>[src]

    impl<'a> PartialEq<VariantInfo<'a>> for VariantInfo<'a>[src]

    impl<'a> StructuralEq for VariantInfo<'a>[src]

    impl<'a> StructuralPartialEq for VariantInfo<'a>[src]

    Auto Trait Implementations

    impl<'a> RefUnwindSafe for VariantInfo<'a>[src]

    impl<'a> !Send for VariantInfo<'a>[src]

    impl<'a> !Sync for VariantInfo<'a>[src]

    impl<'a> Unpin for VariantInfo<'a>[src]

    impl<'a> UnwindSafe for VariantInfo<'a>[src]

    Blanket Implementations

    impl<T> Any for T where
        T: 'static + ?Sized,     [src]

    impl<T> Borrow<T> for T where
        T: ?Sized,     [src]

    impl<T> BorrowMut<T> for T where
        T: ?Sized,     [src]

    impl<T> From<T> for T[src]

    impl<T, U> Into<U> for T where
        U: From<T>,     [src]

    impl<T> ToOwned for T where
        T: Clone,     [src]

    type Owned = T

    The resulting type after obtaining ownership.

    -

    impl<'a> StructuralEq for VariantInfo<'a>[src]

    impl<'a> StructuralPartialEq for VariantInfo<'a>[src]

    Auto Trait Implementations

    impl<'a> RefUnwindSafe for VariantInfo<'a>

    impl<'a> !Send for VariantInfo<'a>

    impl<'a> !Sync for VariantInfo<'a>

    impl<'a> Unpin for VariantInfo<'a>

    impl<'a> UnwindSafe for VariantInfo<'a>

    Blanket Implementations

    impl<T> Any for T where
        T: 'static + ?Sized,     [src]

    impl<T> Borrow<T> for T where
        T: ?Sized,     [src]

    impl<T> BorrowMut<T> for T where
        T: ?Sized,     [src]

    impl<T> From<T> for T[src]

    impl<T, U> Into<U> for T where
        U: From<T>,     [src]

    impl<T> ToOwned for T where
        T: Clone,     [src]

    type Owned = T

    The resulting type after obtaining ownership.

    +

    impl<T, U> TryFrom<U> for T where
        U: Into<T>,     [src]

    type Error = Infallible

    The type returned in the event of a conversion error.

    -

    impl<T, U> TryInto<U> for T where
        U: TryFrom<T>,     [src]

    type Error = <U as TryFrom<T>>::Error

    The type returned in the event of a conversion error.

    -
    \ No newline at end of file +

    impl<T, U> TryFrom<U> for T where
        U: Into<T>,     [src]

    type Error = Infallible

    The type returned in the event of a conversion error.

    +

    impl<T, U> TryInto<U> for T where
        U: TryFrom<T>,     [src]

    type Error = <U as TryFrom<T>>::Error

    The type returned in the event of a conversion error.

    +
    + \ No newline at end of file diff --git a/synstructure/trait.MacroResult.html b/synstructure/trait.MacroResult.html index 0bbb483..a32dac7 100644 --- a/synstructure/trait.MacroResult.html +++ b/synstructure/trait.MacroResult.html @@ -1,13 +1,13 @@ -synstructure::MacroResult - Rust +synstructure::MacroResult - Rust -

    [−][src]Trait synstructure::MacroResult

    pub trait MacroResult {
+
    Trait synstructure::MacroResult[−][src]
    pub trait MacroResult {
     fn into_result(self) -> Result<TokenStream>;
 
     fn into_stream(self) -> TokenStream
        where
            Self: Sized    ,
     { ... }
 }
    Helper trait describing values which may be returned by macro implementation
-methods used by this crate's macros.
    
+methods used by this crate’s macros.
    
 
    Required methods
    fn into_result(self) -> Result<TokenStream>[src]
    Convert this result into a Result for further processing / validation.
    
 
    Loading content...
    Provided methods
    fn into_stream(self) -> TokenStream where
        Self: Sized,     [src]
    Convert this result into a proc_macro::TokenStream, ready to return
 from a native proc_macro implementation.
    
@@ -15,4 +15,5 @@ from a native proc_macro implementation.
    
 generate a compile_error! invocation to nicely report the error.
    
 
    This method is available if synstructure is built with the
 "proc-macro" feature.
    
-
    Loading content...
    Implementations on Foreign Types
    impl MacroResult for TokenStream[src]
    impl MacroResult for TokenStream[src]
    impl<T: MacroResult> MacroResult for Result<T>[src]
    Loading content...
    Implementors
    Loading content...
    
\ No newline at end of file
+
    Loading content...

    Implementations on Foreign Types

    impl MacroResult for TokenStream[src]

    impl MacroResult for TokenStream[src]

    impl<T: MacroResult> MacroResult for Result<T>[src]

    Loading content...

    Implementors

    Loading content...
    + \ No newline at end of file diff --git a/unicode_xid/all.html b/unicode_xid/all.html index 9b081a3..442513e 100644 --- a/unicode_xid/all.html +++ b/unicode_xid/all.html @@ -1,4 +1,5 @@ -List of all items in this crate

    [−] +List of all items in this crate

    List of all items[−] - List of all items

    Traits

    Constants

    \ No newline at end of file +

    Traits

    Constants

    + \ No newline at end of file diff --git a/unicode_xid/constant.UNICODE_VERSION.html b/unicode_xid/constant.UNICODE_VERSION.html index bbed5ce..1955b6d 100644 --- a/unicode_xid/constant.UNICODE_VERSION.html +++ b/unicode_xid/constant.UNICODE_VERSION.html @@ -1,4 +1,5 @@ -unicode_xid::UNICODE_VERSION - Rust

    [−][src]Constant unicode_xid::UNICODE_VERSION

    pub const UNICODE_VERSION: (u64, u64, u64);

    The version of Unicode +unicode_xid::UNICODE_VERSION - Rust

    Constant unicode_xid::UNICODE_VERSION[−][src]

    pub const UNICODE_VERSION: (u64, u64, u64);

    The version of Unicode that this version of unicode-xid is based on.

    -
    \ No newline at end of file +
    + \ No newline at end of file diff --git a/unicode_xid/index.html b/unicode_xid/index.html index 06cde42..2929464 100644 --- a/unicode_xid/index.html +++ b/unicode_xid/index.html @@ -1,5 +1,5 @@ -unicode_xid - Rust

    [−][src]Crate unicode_xid

    Determine if a char is a valid identifier for a parser and/or lexer according to +unicode_xid - Rust

    Crate unicode_xid[−][src]

    Determine if a char is a valid identifier for a parser and/or lexer according to Unicode Standard Annex #31 rules.

    @@ -19,4 +19,5 @@ on std, and instead uses equivalent functions from core.
    
 that this version of unicode-xid is based on.
    
 
    Traits
    
 
    UnicodeXID
    Methods for determining if a character is a valid identifier character.
    
-
    \ No newline at end of file +
    + \ No newline at end of file diff --git a/unicode_xid/trait.UnicodeXID.html b/unicode_xid/trait.UnicodeXID.html index 096daf6..1fb906e 100644 --- a/unicode_xid/trait.UnicodeXID.html +++ b/unicode_xid/trait.UnicodeXID.html @@ -1,16 +1,17 @@ -unicode_xid::UnicodeXID - Rust

    [−][src]Trait unicode_xid::UnicodeXID

    pub trait UnicodeXID {
+unicode_xid::UnicodeXID - Rust
    Trait unicode_xid::UnicodeXID[−][src]
    pub trait UnicodeXID {
     fn is_xid_start(self) -> bool;
 
        fn is_xid_continue(self) -> bool;
 }
    Methods for determining if a character is a valid identifier character.
    
-
    Required methods
    fn is_xid_start(self) -> bool[src]
    Returns whether the specified character satisfies the 'XID_Start'
+
    Required methods
    fn is_xid_start(self) -> bool[src]
    Returns whether the specified character satisfies the ‘XID_Start’
 Unicode property.
    
-
    'XID_Start' is a Unicode Derived Property specified in
+
    ‘XID_Start’ is a Unicode Derived Property specified in
 UAX #31,
 mostly similar to ID_Start but modified for closure under NFKx.
    
-
    fn is_xid_continue(self) -> bool[src]
    Returns whether the specified char satisfies the 'XID_Continue'
+
    fn is_xid_continue(self) -> bool[src]
    Returns whether the specified char satisfies the ‘XID_Continue’
 Unicode property.
    
-
    'XID_Continue' is a Unicode Derived Property specified in
+
    ‘XID_Continue’ is a Unicode Derived Property specified in
 UAX #31,
-mostly similar to 'ID_Continue' but modified for closure under NFKx.
    
-
    Loading content...
    Implementors
    impl UnicodeXID for char[src]
    Loading content...
    
\ No newline at end of file
+mostly similar to ‘ID_Continue’ but modified for closure under NFKx.
    
+
    Loading content...

    Implementors

    impl UnicodeXID for char[src]

    Loading content...
    + \ No newline at end of file