SYMBOL INDEX (1910 symbols across 68 files)

FILE: benches/parse.rs
  function to_borrowed_value (line 19) | fn to_borrowed_value(data: &mut [u8]) {
  function to_borrowed_value_with_buffers (line 23) | fn to_borrowed_value_with_buffers(data: &mut [u8], buffers: &mut Buffers) {
  function to_owned_value (line 27) | fn to_owned_value(data: &mut [u8]) {
  function serde_from_slice (line 32) | fn serde_from_slice(data: &[u8]) {

FILE: benches/to_tape.rs
  function serde_from_slice (line 14) | fn serde_from_slice(data: &[u8]) {

FILE: examples/perf.rs
  constant ROUNDS (line 5) | const ROUNDS: usize = 2000;
  constant WARMUP (line 6) | const WARMUP: usize = 200;
  type Stats (line 15) | struct Stats {
    method new (line 22) | fn new(algo: Implementation) -> Self {
    method start (line 48) | pub fn start(&self) -> Counter {
    method stop (line 66) | pub fn stop(&mut self, mut counter: Counter) {
    method print (line 101) | pub fn print(&self, name: &str, bytes: usize) {
    method print_diff (line 121) | pub fn print_diff(&self, baseline: &Stats, name: &str, bytes: usize) {
  type Stat (line 31) | struct Stat {
  type Counter (line 39) | struct Counter {
  function bench (line 163) | pub fn bench(name: &str, baseline: bool) {
  function bench (line 221) | pub fn bench(_name: &str, _baseline: bool) {
  function main (line 230) | fn main() {

FILE: src/charutils.rs
  constant STRUCTURAL_OR_WHITESPACE_NEGATED (line 3) | const STRUCTURAL_OR_WHITESPACE_NEGATED: [u32; 256] = [
  constant STRUCTURAL_OR_WHITESPACE (line 14) | const STRUCTURAL_OR_WHITESPACE: [u32; 256] = [
  function is_not_structural_or_whitespace (line 26) | pub fn is_not_structural_or_whitespace(c: u8) -> u32 {
  function is_structural_or_whitespace (line 31) | pub fn is_structural_or_whitespace(c: u8) -> u32 {
  constant DIGITTOVAL (line 35) | const DIGITTOVAL: [i8; 256] = [
  function hex_to_u32_nocheck (line 54) | pub fn hex_to_u32_nocheck(src: &[u8]) -> u32 {
  function codepoint_to_utf8 (line 86) | pub fn codepoint_to_utf8(cp: u32, c: &mut [u8]) -> usize {

FILE: src/error.rs
  type ErrorType (line 7) | pub enum ErrorType {
  type InternalError (line 96) | pub enum InternalError {
  method eq (line 108) | fn eq(&self, other: &Self) -> bool {
  type Error (line 155) | pub struct Error {
    method from (line 101) | fn from(e: std::io::Error) -> Self {
    method new (line 165) | pub(crate) fn new(index: usize, character: Option<char>, err_type: Err...
    method new_c (line 172) | pub(crate) fn new_c(index: usize, character: char, error: ErrorType) -...
    method generic (line 178) | pub fn generic(t: ErrorType) -> Self {
    method index (line 188) | pub fn index(&self) -> usize {
    method character (line 194) | pub fn character(&self) -> Option<char> {
    method error (line 200) | pub fn error(&self) -> &ErrorType {
    method is_io (line 210) | pub fn is_io(&self) -> bool {
    method is_eof (line 221) | pub fn is_eof(&self) -> bool {
    method is_data (line 227) | pub fn is_data(&self) -> bool {
    method is_syntax (line 234) | pub fn is_syntax(&self) -> bool {
    method fmt (line 269) | fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
  function from (line 280) | fn from(e: Error) -> Self {

FILE: src/impls/avx2/deser.rs
  function parse_str (line 27) | pub(crate) unsafe fn parse_str<'invoke, 'de>(

FILE: src/impls/avx2/stage1.rs
  type SimdInput (line 38) | pub(crate) struct SimdInput {
  type Utf8Validator (line 44) | type Utf8Validator = simdutf8::basic::imp::x86::avx2::ChunkedUtf8Validat...
  type SimdRepresentation (line 45) | type SimdRepresentation = __m256i;
  method new (line 50) | unsafe fn new(ptr: &[u8]) -> Self {
  method compute_quote_mask (line 63) | unsafe fn compute_quote_mask(quote_bits: u64) -> u64 {
  method compute_quote_mask (line 77) | unsafe fn compute_quote_mask(quote_bits: u64) -> u64 {
  method cmp_mask_against_input (line 91) | unsafe fn cmp_mask_against_input(&self, m: u8) -> u64 {
  method unsigned_lteq_against_input (line 106) | unsafe fn unsigned_lteq_against_input(&self, maxval: __m256i) -> u64 {
  method find_whitespace_and_structurals (line 119) | unsafe fn find_whitespace_and_structurals(&self, whitespace: &mut u64, s...
  method flatten_bits (line 201) | unsafe fn flatten_bits(base: &mut Vec<u32>, idx: u32, mut bits: u64) {
  method fill_s8 (line 255) | unsafe fn fill_s8(n: i8) -> __m256i {

FILE: src/impls/native/deser.rs
  function parse_str (line 8) | pub(crate) unsafe fn parse_str<'invoke, 'de>(
  function deser_str (line 117) | fn deser_str(input: &[u8]) -> Result<String> {
  function easy_string (line 130) | fn easy_string() -> Result<()> {
  function string_with_quote (line 137) | fn string_with_quote() -> Result<()> {
  function string_with_utf8 (line 144) | fn string_with_utf8() -> Result<()> {

FILE: src/impls/native/mod.rs
  type ChunkedUtf8ValidatorImp (line 12) | pub(crate) struct ChunkedUtf8ValidatorImp();
  method new (line 15) | unsafe fn new() -> Self
  method update_from_chunks (line 22) | unsafe fn update_from_chunks(&mut self, _input: &[u8]) {}
  method finalize (line 24) | unsafe fn finalize(

FILE: src/impls/native/stage1.rs
  type V128 (line 5) | type V128 = [u8; 16];
  function u8x16_splat (line 7) | fn u8x16_splat(n: u8) -> V128 {
  function v128_and (line 11) | fn v128_and(a: V128, b: V128) -> V128 {
  function u8x16_shr (line 32) | fn u8x16_shr(a: V128, n: i32) -> V128 {
  function u8x16_swizzle (line 53) | fn u8x16_swizzle(a: V128, s: V128) -> [u8; 16] {
  function bool_to_u8 (line 192) | fn bool_to_u8(b: bool) -> u8 {
  function u8x16_le (line 195) | fn u8x16_le(a: V128, b: V128) -> V128 {
  function u8x16_eq (line 216) | fn u8x16_eq(a: V128, b: V128) -> V128 {
  function u8x16_bitmask (line 237) | fn u8x16_bitmask(a: V128) -> u16 {
  type SimdInput (line 285) | pub(crate) struct SimdInput {
  type Utf8Validator (line 293) | type Utf8Validator = super::ChunkedUtf8ValidatorImp;
  type SimdRepresentation (line 294) | type SimdRepresentation = V128;
  method new (line 295) | unsafe fn new(ptr: &[u8]) -> Self {
  method compute_quote_mask (line 308) | unsafe fn compute_quote_mask(quote_bits: u64) -> u64 {
  method cmp_mask_against_input (line 318) | unsafe fn cmp_mask_against_input(&self, m: u8) -> u64 {
  method unsigned_lteq_against_input (line 331) | unsafe fn unsigned_lteq_against_input(&self, maxval: V128) -> u64 {
  method find_whitespace_and_structurals (line 343) | unsafe fn find_whitespace_and_structurals(&self, whitespace: &mut u64, s...
  method flatten_bits (line 427) | unsafe fn flatten_bits(base: &mut Vec<u32>, idx: u32, mut bits: u64) {
  method fill_s8 (line 478) | unsafe fn fill_s8(n: i8) -> V128 {

FILE: src/impls/neon/deser.rs
  function find_bs_bits_and_quote_bits (line 15) | fn find_bs_bits_and_quote_bits(v0: uint8x16_t, v1: uint8x16_t) -> (u32, ...
  function parse_str (line 45) | pub(crate) fn parse_str<'invoke, 'de>(

FILE: src/impls/neon/stage1.rs
  function bit_mask (line 11) | pub(crate) unsafe fn bit_mask() -> uint8x16_t {
  function neon_movemask_bulk (line 21) | pub unsafe fn neon_movemask_bulk(
  type SimdInput (line 49) | pub(crate) struct SimdInput {
  type Utf8Validator (line 57) | type Utf8Validator = simdutf8::basic::imp::aarch64::neon::ChunkedUtf8Val...
  type SimdRepresentation (line 58) | type SimdRepresentation = int8x16_t;
  method new (line 60) | unsafe fn new(ptr: &[u8]) -> Self {
  method compute_quote_mask (line 72) | unsafe fn compute_quote_mask(mut quote_bits: u64) -> u64 {
  method cmp_mask_against_input (line 84) | unsafe fn cmp_mask_against_input(&self, m: u8) -> u64 {
  method unsigned_lteq_against_input (line 98) | unsafe fn unsigned_lteq_against_input(&self, maxval: int8x16_t) -> u64 {
  method find_whitespace_and_structurals (line 111) | unsafe fn find_whitespace_and_structurals(&self, whitespace: &mut u64, s...
  method flatten_bits (line 187) | unsafe fn flatten_bits(base: &mut Vec<u32>, idx: u32, mut bits: u64) {
  method fill_s8 (line 235) | unsafe fn fill_s8(n: i8) -> int8x16_t {

FILE: src/impls/portable/deser.rs
  function parse_str (line 10) | pub(crate) unsafe fn parse_str<'invoke, 'de>(

FILE: src/impls/portable/stage1.rs
  type SimdInput (line 5) | pub(crate) struct SimdInput {
  type Utf8Validator (line 10) | type Utf8Validator = simdutf8::basic::imp::portable::ChunkedUtf8Validato...
  type SimdRepresentation (line 11) | type SimdRepresentation = u8x64;
  method new (line 13) | unsafe fn new(ptr: &[u8]) -> Self {
  method compute_quote_mask (line 20) | unsafe fn compute_quote_mask(quote_bits: u64) -> u64 {
  method cmp_mask_against_input (line 32) | unsafe fn cmp_mask_against_input(&self, m: u8) -> u64 {
  method unsigned_lteq_against_input (line 39) | unsafe fn unsigned_lteq_against_input(&self, maxval: u8x64) -> u64 {
  method find_whitespace_and_structurals (line 44) | unsafe fn find_whitespace_and_structurals(&self, whitespace: &mut u64, s...
  method flatten_bits (line 109) | unsafe fn flatten_bits(base: &mut Vec<u32>, idx: u32, mut bits: u64) {
  method fill_s8 (line 164) | unsafe fn fill_s8(n: i8) -> u8x64 {

FILE: src/impls/simd128/deser.rs
  function parse_str (line 17) | pub(crate) fn parse_str<'invoke, 'de>(

FILE: src/impls/simd128/stage1.rs
  type SimdInput (line 8) | pub(crate) struct SimdInput {
  type Utf8Validator (line 16) | type Utf8Validator = simdutf8::basic::imp::wasm32::simd128::ChunkedUtf8V...
  type SimdRepresentation (line 17) | type SimdRepresentation = v128;
  method new (line 21) | unsafe fn new(ptr: &[u8]) -> Self {
  method compute_quote_mask (line 31) | unsafe fn compute_quote_mask(mut quote_bits: u64) -> u64 {
  method cmp_mask_against_input (line 46) | unsafe fn cmp_mask_against_input(&self, m: u8) -> u64 {
  method unsigned_lteq_against_input (line 61) | unsafe fn unsigned_lteq_against_input(&self, maxval: v128) -> u64 {
  method find_whitespace_and_structurals (line 75) | unsafe fn find_whitespace_and_structurals(&self, whitespace: &mut u64, s...
  method flatten_bits (line 164) | unsafe fn flatten_bits(base: &mut Vec<u32>, idx: u32, mut bits: u64) {
  method fill_s8 (line 200) | unsafe fn fill_s8(n: i8) -> v128 {

FILE: src/impls/sse42/deser.rs
  function parse_str (line 20) | pub(crate) unsafe fn parse_str<'invoke, 'de>(

FILE: src/impls/sse42/stage1.rs
  type SimdInput (line 38) | pub(crate) struct SimdInput {
  type Utf8Validator (line 46) | type Utf8Validator = simdutf8::basic::imp::x86::sse42::ChunkedUtf8Valida...
  type SimdRepresentation (line 47) | type SimdRepresentation = __m128i;
  method new (line 51) | unsafe fn new(ptr: &[u8]) -> Self {
  method compute_quote_mask (line 66) | unsafe fn compute_quote_mask(quote_bits: u64) -> u64 {
  method compute_quote_mask (line 80) | unsafe fn compute_quote_mask(mut quote_bits: u64) -> u64 {
  method cmp_mask_against_input (line 97) | unsafe fn cmp_mask_against_input(&self, m: u8) -> u64 {
  method unsigned_lteq_against_input (line 116) | unsafe fn unsigned_lteq_against_input(&self, maxval: __m128i) -> u64 {
  method find_whitespace_and_structurals (line 133) | unsafe fn find_whitespace_and_structurals(&self, whitespace: &mut u64, s...
  method flatten_bits (line 247) | unsafe fn flatten_bits(base: &mut Vec<u32>, idx: u32, mut bits: u64) {
  method fill_s8 (line 289) | unsafe fn fill_s8(n: i8) -> __m128i {

FILE: src/known_key.rs
  type NotSoRandomState (line 13) | pub struct NotSoRandomState(RandomState);
  method default (line 16) | fn default() -> Self {
  type Hasher (line 22) | type Hasher = AHasher;
  method build_hasher (line 24) | fn build_hasher(&self) -> AHasher {
  type KnownKey (line 32) | pub struct KnownKey<'key> {
  type Error (line 39) | pub enum Error {
    method fmt (line 46) | fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
  function from (line 58) | fn from(key: S) -> Self {
  function key (line 72) | pub fn key(&self) -> &Cow<'key, str> {
  function lookup (line 94) | pub fn lookup<'target, 'value>(
  function map_lookup (line 122) | pub fn map_lookup<'target, 'value>(
  function lookup_mut (line 156) | pub fn lookup_mut<'target, 'value>(
  function map_lookup_mut (line 190) | pub fn map_lookup_mut<'target, 'value>(
  function lookup_or_insert_mut (line 239) | pub fn lookup_or_insert_mut<'target, 'value, F>(
  function map_lookup_or_insert_mut (line 287) | pub fn map_lookup_or_insert_mut<'target, 'value, F>(
  function insert (line 331) | pub fn insert<'target, 'value>(
  function map_insert (line 376) | pub fn map_insert<'target, 'value>(
  function known_key (line 404) | fn known_key() {
  function known_key_insert (line 420) | fn known_key_insert() {
  function lookup_or_insert_mut (line 443) | fn lookup_or_insert_mut() {
  function known_key_map (line 468) | fn known_key_map() {
  function known_key_insert_map (line 482) | fn known_key_insert_map() {
  function known_key_get_key (line 506) | fn known_key_get_key() {

FILE: src/lib.rs
  constant SIMDJSON_PADDING (line 58) | pub(crate) const SIMDJSON_PADDING: usize = 32;
  constant SIMDINPUT_LENGTH (line 60) | pub(crate) const SIMDINPUT_LENGTH: usize = 64;
  type Result (line 75) | pub type Result<T> = std::result::Result<T, Error>;
  type Buffers (line 90) | pub struct Buffers {
    method new (line 109) | pub fn new(input_len: usize) -> Self {
  method default (line 99) | fn default() -> Self {
  function to_tape (line 126) | pub fn to_tape(s: &mut [u8]) -> Result<Tape<'_>> {
  function to_tape_with_buffers (line 135) | pub fn to_tape_with_buffers<'de>(s: &'de mut [u8], buffers: &mut Buffers...
  function fill_tape (line 144) | pub fn fill_tape<'de>(s: &'de mut [u8], buffers: &mut Buffers, tape: &mu...
  type Stage1Parse (line 149) | pub(crate) trait Stage1Parse {
    method new (line 153) | unsafe fn new(ptr: &[u8]) -> Self;
    method compute_quote_mask (line 155) | unsafe fn compute_quote_mask(quote_bits: u64) -> u64;
    method cmp_mask_against_input (line 157) | unsafe fn cmp_mask_against_input(&self, m: u8) -> u64;
    method unsigned_lteq_against_input (line 159) | unsafe fn unsigned_lteq_against_input(&self, maxval: Self::SimdReprese...
    method find_whitespace_and_structurals (line 161) | unsafe fn find_whitespace_and_structurals(&self, whitespace: &mut u64,...
    method flatten_bits (line 163) | unsafe fn flatten_bits(base: &mut Vec<u32>, idx: u32, bits: u64);
    method find_quote_mask_and_bits (line 177) | fn find_quote_mask_and_bits(
    method find_odd_backslash_sequences (line 215) | fn find_odd_backslash_sequences(&self, prev_iter_ends_odd_backslash: &...
    method finalize_structurals (line 253) | fn finalize_structurals(
    method fill_s8 (line 288) | unsafe fn fill_s8(n: i8) -> Self::SimdRepresentation;
  type Deserializer (line 293) | pub struct Deserializer<'de> {
  type SillyWrapper (line 303) | pub(crate) struct SillyWrapper<'de> {
  function from (line 310) | fn from(input: *mut u8) -> Self {
  type FnRaw (line 322) | type FnRaw = *mut ();
  type ParseStrFn (line 327) | type ParseStrFn = for<'invoke, 'de> unsafe fn(
  type FindStructuralBitsFn (line 337) | type FindStructuralBitsFn = unsafe fn(
  type Implementation (line 344) | pub enum Implementation {
    method fmt (line 360) | fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
  function algorithm (line 379) | pub fn algorithm() -> Implementation {
  function algorithm (line 405) | pub fn algorithm() -> Implementation {
  function algorithm (line 411) | pub fn algorithm() -> Implementation {
  function algorithm (line 422) | pub fn algorithm() -> Implementation {
  function algorithm (line 434) | pub fn algorithm() -> Implementation {
  function algorithm (line 441) | pub fn algorithm() -> Implementation {
  function algorithm (line 448) | pub fn algorithm() -> Implementation {
  function parse_str_ (line 459) | pub(crate) unsafe fn parse_str_<'invoke>(
  function parse_str_ (line 522) | pub(crate) unsafe fn parse_str_<'invoke>(
  function parse_str_ (line 536) | pub(crate) unsafe fn parse_str_<'invoke>(
  function parse_str_ (line 555) | pub(crate) unsafe fn parse_str_<'invoke>(
  function parse_str_ (line 572) | pub(crate) unsafe fn parse_str_<'invoke>(
  function parse_str_ (line 584) | pub(crate) unsafe fn parse_str_<'invoke>(
  function parse_str_ (line 595) | pub(crate) unsafe fn parse_str_<'invoke>(
  function find_structural_bits (line 613) | pub(crate) unsafe fn find_structural_bits(
  function find_structural_bits (line 666) | pub(crate) unsafe fn find_structural_bits(
  function find_structural_bits (line 684) | pub(crate) unsafe fn find_structural_bits(
  function find_structural_bits (line 699) | pub(crate) unsafe fn find_structural_bits(
  function find_structural_bits (line 713) | pub(crate) unsafe fn find_structural_bits(
  function find_structural_bits (line 722) | pub(crate) unsafe fn find_structural_bits(
  function find_structural_bits (line 731) | pub(crate) unsafe fn find_structural_bits(
  function into_tape (line 744) | pub fn into_tape(self) -> Tape<'de> {
  function as_value (line 750) | pub fn as_value(&self) -> Value<'_, 'de> {
  function restart (line 756) | pub fn restart(&mut self) {
  function error (line 762) | fn error(error: ErrorType) -> Error {
  function error_c (line 767) | fn error_c(idx: usize, c: char, error: ErrorType) -> Error {
  function from_slice (line 776) | pub fn from_slice(input: &'de mut [u8]) -> Result<Self> {
  function fill_tape (line 793) | fn fill_tape(
  function from_slice_with_buffers (line 853) | pub fn from_slice_with_buffers(input: &'de mut [u8], buffer: &mut Buffer...
  function skip (line 863) | fn skip(&mut self) {
  function next_ (line 875) | pub unsafe fn next_(&mut self) -> Node<'de> {
  function _find_structural_bits (line 883) | pub(crate) unsafe fn _find_structural_bits<S: Stage1Parse>(
  type AlignedBuf (line 1036) | struct AlignedBuf {
    method with_capacity (line 1053) | pub fn with_capacity(capacity: usize) -> Self {
    method as_mut_ptr (line 1073) | fn as_mut_ptr(&mut self) -> *mut u8 {
    method capacity_overflow (line 1077) | fn capacity_overflow() -> ! {
    method capacity (line 1080) | fn capacity(&self) -> usize {
    method set_len (line 1083) | unsafe fn set_len(&mut self, n: usize) {
  method drop (line 1094) | fn drop(&mut self) {
  type Target (line 1102) | type Target = [u8];
  method deref (line 1104) | fn deref(&self) -> &Self::Target {
  method deref_mut (line 1110) | fn deref_mut(&mut self) -> &mut Self::Target {

FILE: src/macros.rs
  function owned_test_map (line 1281) | fn owned_test_map() -> OwnedValue {
  function borrowed_test_map (line 1287) | fn borrowed_test_map() -> BorrowedValue<'static> {
  function array (line 1294) | fn array() {
  function obj (line 1305) | fn obj() {
  function array_typed_owned (line 1317) | fn array_typed_owned() {
  function array_typed_borrowed (line 1327) | fn array_typed_borrowed() {
  function obj_typed_owned (line 1337) | fn obj_typed_owned() {
  function obj_typed_borrowed (line 1350) | fn obj_typed_borrowed() {

FILE: src/numberparse.rs
  function is_integer (line 25) | pub fn is_integer(c: u8) -> bool {
  constant STRUCTURAL_OR_WHITESPACE_OR_EXPONENT_OR_DECIMAL_NEGATED (line 32) | const STRUCTURAL_OR_WHITESPACE_OR_EXPONENT_OR_DECIMAL_NEGATED: [bool; 25...
  function is_not_structural_or_whitespace_or_exponent_or_decimal (line 53) | fn is_not_structural_or_whitespace_or_exponent_or_decimal(c: u8) -> bool {
  function is_made_of_eight_digits_fast (line 67) | fn is_made_of_eight_digits_fast(chars: [u8; 8]) -> bool {
  function parse_eight_digits_ssse3 (line 86) | unsafe fn parse_eight_digits_ssse3(chars: &[u8]) -> u32 {
  function parse_eight_digits_swar (line 115) | fn parse_eight_digits_swar(chars: &[u8]) -> u32 {
  function parse_eight_digits_unrolled (line 125) | fn parse_eight_digits_unrolled(chars: &[u8]) -> u32 {

FILE: src/numberparse/approx.rs
  constant POWER_OF_TEN (line 11) | const POWER_OF_TEN: [f64; 632] = [
  function parse_float (line 81) | fn parse_float(idx: usize, p: &[u8], negative: bool) -> Result<StaticNod...
  function parse_large_integer (line 226) | fn parse_large_integer(idx: usize, buf: &[u8], negative: bool) -> Result...
  function parse_large_integer (line 287) | fn parse_large_integer(idx: usize, buf: &[u8], negative: bool) -> Result...
  function parse_number (line 362) | pub(crate) fn parse_number(idx: usize, buf: &[u8], negative: bool) -> Re...
  function bad_exp (line 568) | fn bad_exp() {
  function bad_dot (line 605) | fn bad_dot() {
  function bad_e (line 625) | fn bad_e() {
  function zero (line 645) | fn zero() {
  function float_zero (line 653) | fn float_zero() {
  function minus_309 (line 661) | fn minus_309() {
  function tiny_float (line 673) | fn tiny_float() {

FILE: src/numberparse/correct.rs
  function multiply_as_u128 (line 47) | fn multiply_as_u128(a: u64, b: u64) -> (u64, u64) {
  function parse_number (line 59) | pub(crate) fn parse_number(idx: usize, buf: &[u8], negative: bool) -> Re...
  function parse_large_integer (line 208) | fn parse_large_integer(
  function parse_large_integer (line 250) | fn parse_large_integer(
  function f64_from_parts (line 311) | fn f64_from_parts(
  function f64_from_parts_slow (line 384) | fn f64_from_parts_slow(slice: &[u8], offset: usize) -> Result<StaticNode> {
  function to_value_from_str (line 408) | fn to_value_from_str(buf: &str) -> Result<Value, Error> {
  function float (line 416) | fn float() -> Result<(), crate::Error> {
  function float_precision (line 452) | fn float_precision() -> Result<(), crate::Error> {
  function int_trailing_invalid (line 481) | fn int_trailing_invalid() {
  function float_trailing_invalid (line 488) | fn float_trailing_invalid() {
  function bad_dot (line 497) | fn bad_dot() {
  function bad_e (line 505) | fn bad_e() {
  function infinite_literal (line 512) | fn infinite_literal() {
  function infinite_exponent (line 524) | fn infinite_exponent() {
  function nan (line 532) | fn nan() {
  function zero_int (line 538) | fn zero_int() -> Result<(), crate::Error> {
  function zero_float (line 544) | fn zero_float() -> Result<(), crate::Error> {
  function int (line 559) | fn int() -> Result<(), crate::Error> {
  function minus_309 (line 567) | fn minus_309() -> Result<(), crate::Error> {
  function tiny_float (line 576) | fn tiny_float() -> Result<(), crate::Error> {
  function huge_int (line 583) | fn huge_int() -> Result<(), crate::Error> {

FILE: src/numberparse/correct/numberconst.rs
  constant POW10_COMPONENTS (line 2) | pub(crate) const POW10_COMPONENTS: [(u64, i32); 634] = [
  constant MANTISSA_128 (line 640) | pub(crate) const MANTISSA_128: [u64; 634] = [
  constant POW10 (line 1277) | pub(crate) const POW10: [f64; 23] = [

FILE: src/portability.rs
  function add_overflow (line 8) | pub fn add_overflow(value1: u64, value2: u64, result: &mut u64) -> bool {
  function hamming (line 16) | pub fn hamming(input_num: u64) -> u32 {
  function hamming (line 22) | pub fn hamming(input_num: u64) -> u32 {
  function trailingzeroes (line 28) | pub fn trailingzeroes(input_num: u64) -> u32 {

FILE: src/safer_unchecked.rs
  type GetSaferUnchecked (line 3) | pub trait GetSaferUnchecked<T> {
    method get_kinda_unchecked (line 4) | unsafe fn get_kinda_unchecked<I>(&self, index: I) -> &<I as SliceIndex...
    method get_kinda_unchecked_mut (line 8) | unsafe fn get_kinda_unchecked_mut<I>(
  function get_kinda_unchecked (line 18) | unsafe fn get_kinda_unchecked<I>(&self, index: I) -> &<I as SliceIndex<[...
  function get_kinda_unchecked_mut (line 30) | unsafe fn get_kinda_unchecked_mut<I>(&mut self, index: I) -> &mut <I as ...

FILE: src/serde.rs
  type ConvertResult (line 21) | type ConvertResult<T> = std::result::Result<T, SerdeConversionError>;
  type SerdeConversionError (line 25) | pub enum SerdeConversionError {
    method fmt (line 34) | fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
  function from_slice (line 56) | pub fn from_slice<'a, T>(s: &'a mut [u8]) -> Result<T>
  function from_slice_with_buffers (line 73) | pub fn from_slice_with_buffers<'a, T>(s: &'a mut [u8], buffers: &mut Buf...
  function from_str (line 97) | pub unsafe fn from_str<'a, T>(s: &'a mut str) -> Result<T>
  function from_str_with_buffers (line 124) | pub unsafe fn from_str_with_buffers<'a, T>(s: &'a mut str, buffers: &mut...
  function from_reader (line 150) | pub fn from_reader<R, T>(mut rdr: R) -> Result<T>
  function from_reader_with_buffers (line 172) | pub fn from_reader_with_buffers<R, T>(mut rdr: R, buffers: &mut Buffers)...
  function next (line 200) | fn next(&mut self) -> Result<Node<'de>> {
  function peek (line 211) | fn peek(&self) -> Result<Node<'de>> {
  function parse_u8 (line 220) | fn parse_u8(&mut self) -> Result<u8> {
  function parse_u16 (line 231) | fn parse_u16(&mut self) -> Result<u16> {
  function parse_u32 (line 243) | fn parse_u32(&mut self) -> Result<u32> {
  function parse_u64 (line 254) | fn parse_u64(&mut self) -> Result<u64> {
  function parse_u128 (line 265) | fn parse_u128(&mut self) -> Result<u128> {
  function parse_i8 (line 276) | fn parse_i8(&mut self) -> Result<i8> {
  function parse_i16 (line 287) | fn parse_i16(&mut self) -> Result<i16> {
  function parse_i32 (line 298) | fn parse_i32(&mut self) -> Result<i32> {
  function parse_i64 (line 309) | fn parse_i64(&mut self) -> Result<i64> {
  function parse_i128 (line 320) | fn parse_i128(&mut self) -> Result<i128> {
  function parse_double (line 331) | fn parse_double(&mut self) -> Result<f64> {
  type Error (line 343) | type Error = SerdeConversionError;
  method try_from (line 344) | fn try_from(item: serde_json::Value) -> ConvertResult<Self> {
  type Error (line 374) | type Error = SerdeConversionError;
  method try_into (line 375) | fn try_into(self) -> ConvertResult<serde_json::Value> {
  type Error (line 418) | type Error = SerdeConversionError;
    method custom (line 186) | fn custom<T: fmt::Display>(msg: T) -> Self {
    method custom (line 192) | fn custom<T: fmt::Display>(msg: T) -> Self {
  function try_from (line 419) | fn try_from(item: serde_json::Value) -> ConvertResult<Self> {
  type Error (line 441) | type Error = SerdeConversionError;
    method custom (line 186) | fn custom<T: fmt::Display>(msg: T) -> Self {
    method custom (line 192) | fn custom<T: fmt::Display>(msg: T) -> Self {
  function try_into (line 442) | fn try_into(self) -> ConvertResult<serde_json::Value> {
  type UnitStruct (line 497) | struct UnitStruct;
  type NewTypeStruct (line 499) | struct NewTypeStruct(u8);
  type TupleStruct (line 501) | struct TupleStruct(u8, u8);
  type TestStruct (line 503) | struct TestStruct {
  type TestStruct2 (line 507) | struct TestStruct2 {
  type E (line 511) | enum E {
  type TestPoint (line 519) | struct TestPoint(f64, f64);
  function convert_owned_value (line 522) | fn convert_owned_value() {
  function convert_borrowed_value (line 585) | fn convert_borrowed_value() {
  function option_field_absent (line 641) | fn option_field_absent() {
  function option_field_present (line 660) | fn option_field_present() {
  function convert_enum (line 680) | fn convert_enum() {
  type Foo (line 743) | pub struct Foo {
  type Bar (line 749) | pub enum Bar {
  function object_simd_json (line 754) | fn object_simd_json() {
  function simple_simd_json (line 761) | fn simple_simd_json() {
  function array_as_struct (line 768) | fn array_as_struct() {
  function floats (line 788) | fn floats() {
  function vectors (line 809) | fn vectors() {
  function test_parsing_errors (line 883) | fn test_parsing_errors() {
  function maps (line 926) | fn maps() {

FILE: src/serde/de.rs
  type Error (line 11) | type Error = Error;
  function deserialize_any (line 17) | fn deserialize_any<V>(self, visitor: V) -> Result<V::Value>
  function deserialize_bool (line 53) | fn deserialize_bool<V>(self, visitor: V) -> Result<V::Value>
  function deserialize_str (line 66) | fn deserialize_str<V>(self, visitor: V) -> Result<V::Value>
  function deserialize_string (line 78) | fn deserialize_string<V>(self, visitor: V) -> Result<V::Value>
  function deserialize_i8 (line 93) | fn deserialize_i8<V>(self, visitor: V) -> Result<V::Value>
  function deserialize_i16 (line 102) | fn deserialize_i16<V>(self, visitor: V) -> Result<V::Value>
  function deserialize_i32 (line 111) | fn deserialize_i32<V>(self, visitor: V) -> Result<V::Value>
  function deserialize_i64 (line 119) | fn deserialize_i64<V>(self, visitor: V) -> Result<V::Value>
  function deserialize_i128 (line 127) | fn deserialize_i128<V>(self, visitor: V) -> Result<V::Value>
  function deserialize_u8 (line 136) | fn deserialize_u8<V>(self, visitor: V) -> Result<V::Value>
  function deserialize_u16 (line 145) | fn deserialize_u16<V>(self, visitor: V) -> Result<V::Value>
  function deserialize_u32 (line 154) | fn deserialize_u32<V>(self, visitor: V) -> Result<V::Value>
  function deserialize_u64 (line 162) | fn deserialize_u64<V>(self, visitor: V) -> Result<V::Value>
  function deserialize_u128 (line 170) | fn deserialize_u128<V>(self, visitor: V) -> Result<V::Value>
  function deserialize_f32 (line 179) | fn deserialize_f32<V>(self, visitor: V) -> Result<V::Value>
  function deserialize_f64 (line 188) | fn deserialize_f64<V>(self, visitor: V) -> Result<V::Value>
  function deserialize_option (line 205) | fn deserialize_option<V>(self, visitor: V) -> Result<V::Value>
  function deserialize_unit (line 219) | fn deserialize_unit<V>(self, visitor: V) -> Result<V::Value>
  function deserialize_seq (line 233) | fn deserialize_seq<V>(self, visitor: V) -> Result<V::Value>
  function deserialize_tuple (line 254) | fn deserialize_tuple<V>(self, _len: usize, visitor: V) -> Result<V::Value>
  function deserialize_tuple_struct (line 265) | fn deserialize_tuple_struct<V>(
  function deserialize_unit_struct (line 278) | fn deserialize_unit_struct<V>(self, _name: &'static str, visitor: V) -> ...
  function deserialize_newtype_struct (line 288) | fn deserialize_newtype_struct<V>(self, _name: &'static str, visitor: V) ...
  function deserialize_map (line 296) | fn deserialize_map<V>(self, visitor: V) -> Result<V::Value>
  function deserialize_struct (line 310) | fn deserialize_struct<V>(
  function deserialize_enum (line 328) | fn deserialize_enum<V>(
  type VariantAccess (line 357) | struct VariantAccess<'a, 'de> {
  function new (line 362) | fn new(de: &'a mut Deserializer<'de>) -> Self {
  type Error (line 368) | type Error = Error;
  type Variant (line 369) | type Variant = Self;
  function variant_seed (line 371) | fn variant_seed<V>(self, seed: V) -> Result<(V::Value, Self)>
  type Error (line 381) | type Error = Error;
  function unit_variant (line 383) | fn unit_variant(self) -> Result<()> {
  function newtype_variant_seed (line 387) | fn newtype_variant_seed<T>(self, seed: T) -> Result<T::Value>
  function tuple_variant (line 394) | fn tuple_variant<V>(self, _len: usize, visitor: V) -> Result<V::Value>
  function struct_variant (line 401) | fn struct_variant<V>(self, fields: &'static [&'static str], visitor: V) ...
  type CommaSeparated (line 412) | struct CommaSeparated<'a, 'de: 'a> {
  function new (line 418) | fn new(de: &'a mut Deserializer<'de>, len: usize) -> Self {
  type Error (line 426) | type Error = Error;
  function next_element_seed (line 429) | fn next_element_seed<T>(&mut self, seed: T) -> Result<Option<T::Value>>
  function size_hint (line 441) | fn size_hint(&self) -> Option<usize> {
  type Error (line 449) | type Error = Error;
  function next_key_seed (line 452) | fn next_key_seed<K>(&mut self, seed: K) -> Result<Option<K::Value>>
  function next_value_seed (line 465) | fn next_value_seed<V>(&mut self, seed: V) -> Result<V::Value>
  function size_hint (line 474) | fn size_hint(&self) -> Option<usize> {
  type MapKey (line 481) | struct MapKey<'de: 'a, 'a> {
  type Error (line 502) | type Error = Error;
  function deserialize_any (line 505) | fn deserialize_any<V>(self, visitor: V) -> Result<V::Value>
  function deserialize_option (line 530) | fn deserialize_option<V>(self, visitor: V) -> Result<V::Value>
  function deserialize_newtype_struct (line 539) | fn deserialize_newtype_struct<V>(self, _name: &'static str, visitor: V) ...
  function deserialize_enum (line 547) | fn deserialize_enum<V>(
  function deserialize_bytes (line 560) | fn deserialize_bytes<V>(self, visitor: V) -> Result<V::Value>
  function deserialize_byte_buf (line 568) | fn deserialize_byte_buf<V>(self, visitor: V) -> Result<V::Value>

FILE: src/serde/de/tests.rs
  constant JSON (line 7) | const JSON: &str = r#"{
  type GuildCreate (line 18) | pub enum GuildCreate {
  type UnavailableGuild (line 24) | pub struct UnavailableGuild {
  type Guild (line 29) | pub struct Guild {
  type Channel (line 34) | pub struct Channel {
  type AutoArchiveDuration (line 42) | pub enum AutoArchiveDuration {
    method from (line 51) | fn from(value: u16) -> Self {
    method deserialize (line 63) | fn deserialize<D: Deserializer<'de>>(deserializer: D) -> Result<Self, ...
  type U16EnumVisitor (line 68) | pub struct U16EnumVisitor;
    type Value (line 71) | type Value = u16;
    method expecting (line 73) | fn expecting(&self, f: &mut Formatter<'_>) -> FmtResult {
    method visit_u16 (line 77) | fn visit_u16<E: DeError>(self, value: u16) -> Result<Self::Value, E> {
    method visit_u64 (line 81) | fn visit_u64<E>(self, v: u64) -> Result<Self::Value, E>
  function test_deser_u16 (line 98) | fn test_deser_u16() -> Result<(), Box<dyn std::error::Error>> {

FILE: src/serde/se.rs
  function to_vec (line 19) | pub fn to_vec<T>(to: &T) -> crate::Result<Vec<u8>>
  function to_string (line 33) | pub fn to_string<T>(to: &T) -> crate::Result<String>
  function to_writer (line 44) | pub fn to_writer<T, W>(writer: W, to: &T) -> crate::Result<()>
  type Serializer (line 52) | struct Serializer<W: Write>(W);
  type T (line 58) | type T = W;
  method get_writer (line 60) | fn get_writer(&mut self) -> &mut Self::T {
  method write_min (line 64) | fn write_min(&mut self, _slice: &[u8], min: u8) -> std::io::Result<()> {
  type SerializeSeq (line 68) | struct SerializeSeq<'serializer, W: Write + 'serializer> {
  type Ok (line 76) | type Ok = ();
  type Error (line 77) | type Error = Error;
  function serialize_element (line 79) | fn serialize_element<T>(&mut self, value: &T) -> Result<(), Self::Error>
  function end (line 96) | fn end(self) -> Result<Self::Ok, Self::Error> {
  type Ok (line 109) | type Ok = ();
  type Error (line 110) | type Error = Error;
  function serialize_element (line 112) | fn serialize_element<T>(&mut self, value: &T) -> Result<(), Self::Error>
  function end (line 128) | fn end(self) -> Result<Self::Ok, Self::Error> {
  type Ok (line 141) | type Ok = ();
  type Error (line 142) | type Error = Error;
  function serialize_field (line 144) | fn serialize_field<T>(&mut self, value: &T) -> Result<(), Self::Error>
  function end (line 160) | fn end(self) -> Result<Self::Ok, Self::Error> {
  type Ok (line 173) | type Ok = ();
  type Error (line 174) | type Error = Error;
  function serialize_field (line 176) | fn serialize_field<T>(&mut self, value: &T) -> Result<(), Self::Error>
  function end (line 192) | fn end(self) -> Result<Self::Ok, Self::Error> {
  type SerializeMap (line 201) | struct SerializeMap<'serializer, W: Write + 'serializer> {
  type Ok (line 211) | type Ok = ();
  type Error (line 212) | type Error = Error;
  function serialize_key (line 214) | fn serialize_key<T>(&mut self, key: &T) -> Result<(), Self::Error>
  function serialize_value (line 235) | fn serialize_value<T>(&mut self, value: &T) -> Result<(), Self::Error>
  function end (line 243) | fn end(self) -> Result<Self::Ok, Self::Error> {
  function key_must_be_a_string (line 252) | fn key_must_be_a_string() -> Error {
  type MapKeySerializer (line 256) | struct MapKeySerializer<'serializer, W: Write + 'serializer> {
  type Ok (line 264) | type Ok = ();
  type Error (line 265) | type Error = Error;
  function serialize_str (line 268) | fn serialize_str(self, value: &str) -> Result<(), Self::Error> {
  function serialize_unit_variant (line 273) | fn serialize_unit_variant(
  function serialize_newtype_struct (line 283) | fn serialize_newtype_struct<T>(self, _name: &'static str, value: &T) -> ...
  type SerializeSeq (line 290) | type SerializeSeq = ser::Impossible<(), Error>;
  type SerializeTuple (line 291) | type SerializeTuple = ser::Impossible<(), Error>;
  type SerializeTupleStruct (line 292) | type SerializeTupleStruct = ser::Impossible<(), Error>;
  type SerializeTupleVariant (line 293) | type SerializeTupleVariant = ser::Impossible<(), Error>;
  type SerializeMap (line 294) | type SerializeMap = ser::Impossible<(), Error>;
  type SerializeStruct (line 295) | type SerializeStruct = ser::Impossible<(), Error>;
  type SerializeStructVariant (line 296) | type SerializeStructVariant = ser::Impossible<(), Error>;
  function serialize_bool (line 298) | fn serialize_bool(self, _value: bool) -> Result<(), Self::Error> {
  function serialize_i8 (line 302) | fn serialize_i8(self, v: i8) -> Result<Self::Ok, Self::Error> {
  function serialize_i16 (line 311) | fn serialize_i16(self, v: i16) -> Result<Self::Ok, Self::Error> {
  function serialize_i32 (line 320) | fn serialize_i32(self, v: i32) -> Result<Self::Ok, Self::Error> {
  function serialize_i64 (line 329) | fn serialize_i64(self, v: i64) -> Result<Self::Ok, Self::Error> {
  function serialize_i128 (line 338) | fn serialize_i128(self, v: i128) -> Result<Self::Ok, Self::Error> {
  function serialize_u8 (line 347) | fn serialize_u8(self, v: u8) -> Result<Self::Ok, Self::Error> {
  function serialize_u16 (line 356) | fn serialize_u16(self, v: u16) -> Result<Self::Ok, Self::Error> {
  function serialize_u32 (line 365) | fn serialize_u32(self, v: u32) -> Result<Self::Ok, Self::Error> {
  function serialize_u64 (line 374) | fn serialize_u64(self, v: u64) -> Result<Self::Ok, Self::Error> {
  function serialize_u128 (line 383) | fn serialize_u128(self, v: u128) -> Result<Self::Ok, Self::Error> {
  function serialize_f32 (line 392) | fn serialize_f32(self, _v: f32) -> Result<Self::Ok, Self::Error> {
  function serialize_f64 (line 396) | fn serialize_f64(self, _v: f64) -> Result<Self::Ok, Self::Error> {
  function serialize_char (line 400) | fn serialize_char(self, v: char) -> Result<Self::Ok, Self::Error> {
  function serialize_bytes (line 404) | fn serialize_bytes(self, _v: &[u8]) -> Result<Self::Ok, Self::Error> {
  function serialize_none (line 408) | fn serialize_none(self) -> Result<Self::Ok, Self::Error> {
  function serialize_some (line 412) | fn serialize_some<T>(self, _value: &T) -> Result<Self::Ok, Self::Error>
  function serialize_unit (line 419) | fn serialize_unit(self) -> Result<Self::Ok, Self::Error> {
  function serialize_unit_struct (line 423) | fn serialize_unit_struct(self, _name: &'static str) -> Result<Self::Ok, ...
  function serialize_newtype_variant (line 427) | fn serialize_newtype_variant<T>(
  function serialize_seq (line 440) | fn serialize_seq(self, _len: Option<usize>) -> Result<Self::SerializeSeq...
  function serialize_tuple (line 444) | fn serialize_tuple(self, _len: usize) -> Result<Self::SerializeTuple, Se...
  function serialize_tuple_struct (line 448) | fn serialize_tuple_struct(
  function serialize_tuple_variant (line 456) | fn serialize_tuple_variant(
  function serialize_map (line 466) | fn serialize_map(self, _len: Option<usize>) -> Result<Self::SerializeMap...
  function serialize_struct (line 470) | fn serialize_struct(
  function serialize_struct_variant (line 478) | fn serialize_struct_variant(
  type Ok (line 493) | type Ok = ();
  type Error (line 494) | type Error = Error;
  function serialize_field (line 496) | fn serialize_field<T>(&mut self, key: &'static str, value: &T) -> Result...
  function end (line 519) | fn end(self) -> Result<Self::Ok, Self::Error> {
  type SerializeStructVariant (line 528) | struct SerializeStructVariant<'serializer, W: Write + 'serializer> {
  type Ok (line 537) | type Ok = ();
  type Error (line 538) | type Error = Error;
  function serialize_field (line 540) | fn serialize_field<T>(&mut self, key: &'static str, value: &T) -> Result...
  function end (line 563) | fn end(self) -> Result<Self::Ok, Self::Error> {
  type Ok (line 578) | type Ok = ();
  type Error (line 579) | type Error = Error;
  type SerializeSeq (line 580) | type SerializeSeq = SerializeSeq<'writer, W>;
  type SerializeTuple (line 581) | type SerializeTuple = SerializeSeq<'writer, W>;
  type SerializeTupleStruct (line 582) | type SerializeTupleStruct = SerializeSeq<'writer, W>;
  type SerializeTupleVariant (line 583) | type SerializeTupleVariant = SerializeSeq<'writer, W>;
  type SerializeMap (line 584) | type SerializeMap = SerializeMap<'writer, W>;
  type SerializeStruct (line 585) | type SerializeStruct = SerializeMap<'writer, W>;
  type SerializeStructVariant (line 586) | type SerializeStructVariant = SerializeStructVariant<'writer, W>;
  function serialize_bool (line 588) | fn serialize_bool(self, v: bool) -> Result<Self::Ok, Self::Error> {
  function serialize_i8 (line 596) | fn serialize_i8(self, v: i8) -> Result<Self::Ok, Self::Error> {
  function serialize_i16 (line 600) | fn serialize_i16(self, v: i16) -> Result<Self::Ok, Self::Error> {
  function serialize_i32 (line 604) | fn serialize_i32(self, v: i32) -> Result<Self::Ok, Self::Error> {
  function serialize_i64 (line 608) | fn serialize_i64(self, v: i64) -> Result<Self::Ok, Self::Error> {
  function serialize_i128 (line 612) | fn serialize_i128(self, v: i128) -> Result<Self::Ok, Self::Error> {
  function serialize_u8 (line 616) | fn serialize_u8(self, v: u8) -> Result<Self::Ok, Self::Error> {
  function serialize_u16 (line 620) | fn serialize_u16(self, v: u16) -> Result<Self::Ok, Self::Error> {
  function serialize_u32 (line 624) | fn serialize_u32(self, v: u32) -> Result<Self::Ok, Self::Error> {
  function serialize_u64 (line 628) | fn serialize_u64(self, v: u64) -> Result<Self::Ok, Self::Error> {
  function serialize_u128 (line 632) | fn serialize_u128(self, v: u128) -> Result<Self::Ok, Self::Error> {
  function serialize_f32 (line 637) | fn serialize_f32(self, v: f32) -> Result<Self::Ok, Self::Error> {
  function serialize_f64 (line 641) | fn serialize_f64(self, v: f64) -> Result<Self::Ok, Self::Error> {
  function serialize_char (line 645) | fn serialize_char(self, v: char) -> Result<Self::Ok, Self::Error> {
  function serialize_str (line 652) | fn serialize_str(self, v: &str) -> Result<Self::Ok, Self::Error> {
  function serialize_bytes (line 656) | fn serialize_bytes(self, v: &[u8]) -> Result<Self::Ok, Self::Error> {
  function serialize_none (line 671) | fn serialize_none(self) -> Result<Self::Ok, Self::Error> {
  function serialize_some (line 675) | fn serialize_some<T>(self, value: &T) -> Result<Self::Ok, Self::Error>
  function serialize_unit (line 682) | fn serialize_unit(self) -> Result<Self::Ok, Self::Error> {
  function serialize_unit_struct (line 686) | fn serialize_unit_struct(self, _name: &'static str) -> Result<Self::Ok, ...
  function serialize_unit_variant (line 690) | fn serialize_unit_variant(
  function serialize_newtype_struct (line 700) | fn serialize_newtype_struct<T>(
  function serialize_newtype_variant (line 712) | fn serialize_newtype_variant<T>(
  function serialize_seq (line 731) | fn serialize_seq(self, len: Option<usize>) -> Result<Self::SerializeSeq,...
  function serialize_tuple (line 744) | fn serialize_tuple(self, len: usize) -> Result<Self::SerializeTuple, Sel...
  function serialize_tuple_struct (line 749) | fn serialize_tuple_struct(
  function serialize_tuple_variant (line 758) | fn serialize_tuple_variant(
  function serialize_map (line 774) | fn serialize_map(self, len: Option<usize>) -> Result<Self::SerializeMap,...
  function serialize_struct (line 790) | fn serialize_struct(
  function serialize_struct_variant (line 799) | fn serialize_struct_variant(
  function enum_tuple (line 834) | fn enum_tuple() {
  function print_serde (line 848) | fn print_serde() {
  function numerical_map_serde (line 861) | fn numerical_map_serde() {
  function arb_json_value (line 883) | fn arb_json_value() -> BoxedStrategy<Value> {
  function arb_json_value (line 915) | fn arb_json_value() -> BoxedStrategy<Value> {

FILE: src/serde/se/pp.rs
  function to_vec_pretty (line 19) | pub fn to_vec_pretty<T>(to: &T) -> crate::Result<Vec<u8>>
  function to_string_pretty (line 33) | pub fn to_string_pretty<T>(to: &T) -> crate::Result<String>
  function to_writer_pretty (line 44) | pub fn to_writer_pretty<T, W>(writer: W, to: &T) -> crate::Result<()>
  type PrettySerializer (line 52) | struct PrettySerializer<W: Write> {
  function new (line 57) | fn new(writer: W) -> Self {
  type T (line 66) | type T = W;
  method get_writer (line 68) | fn get_writer(&mut self) -> &mut Self::T {
  method write_min (line 72) | fn write_min(&mut self, _slice: &[u8], min: u8) -> std::io::Result<()> {
  method new_line (line 76) | fn new_line(&mut self) -> std::io::Result<()> {
  method indent (line 97) | fn indent(&mut self) {
  method dedent (line 101) | fn dedent(&mut self) {
  type SerializeSeq (line 105) | struct SerializeSeq<'serializer, W: Write + 'serializer> {
  type Ok (line 113) | type Ok = ();
  type Error (line 114) | type Error = Error;
  function serialize_element (line 116) | fn serialize_element<T>(&mut self, value: &T) -> Result<(), Self::Error>
  function end (line 134) | fn end(self) -> Result<Self::Ok, Self::Error> {
  type Ok (line 148) | type Ok = ();
  type Error (line 149) | type Error = Error;
  function serialize_element (line 151) | fn serialize_element<T>(&mut self, value: &T) -> Result<(), Self::Error>
  function end (line 168) | fn end(self) -> Result<Self::Ok, Self::Error> {
  type Ok (line 182) | type Ok = ();
  type Error (line 183) | type Error = Error;
  function serialize_field (line 185) | fn serialize_field<T>(&mut self, value: &T) -> Result<(), Self::Error>
  function end (line 202) | fn end(self) -> Result<Self::Ok, Self::Error> {
  type Ok (line 216) | type Ok = ();
  type Error (line 217) | type Error = Error;
  function serialize_field (line 219) | fn serialize_field<T>(&mut self, value: &T) -> Result<(), Self::Error>
  function end (line 236) | fn end(self) -> Result<Self::Ok, Self::Error> {
  type MapKeySerializer (line 246) | struct MapKeySerializer<'serializer, W: Write + 'serializer> {
  type Ok (line 254) | type Ok = ();
  type Error (line 255) | type Error = Error;
  function serialize_str (line 258) | fn serialize_str(self, value: &str) -> Result<(), Self::Error> {
  function serialize_unit_variant (line 263) | fn serialize_unit_variant(
  function serialize_newtype_struct (line 273) | fn serialize_newtype_struct<T>(self, _name: &'static str, value: &T) -> ...
  type SerializeSeq (line 280) | type SerializeSeq = ser::Impossible<(), Error>;
  type SerializeTuple (line 281) | type SerializeTuple = ser::Impossible<(), Error>;
  type SerializeTupleStruct (line 282) | type SerializeTupleStruct = ser::Impossible<(), Error>;
  type SerializeTupleVariant (line 283) | type SerializeTupleVariant = ser::Impossible<(), Error>;
  type SerializeMap (line 284) | type SerializeMap = ser::Impossible<(), Error>;
  type SerializeStruct (line 285) | type SerializeStruct = ser::Impossible<(), Error>;
  type SerializeStructVariant (line 286) | type SerializeStructVariant = ser::Impossible<(), Error>;
  function serialize_bool (line 288) | fn serialize_bool(self, _value: bool) -> Result<(), Self::Error> {
  function serialize_i8 (line 292) | fn serialize_i8(self, v: i8) -> Result<Self::Ok, Self::Error> {
  function serialize_i16 (line 301) | fn serialize_i16(self, v: i16) -> Result<Self::Ok, Self::Error> {
  function serialize_i32 (line 310) | fn serialize_i32(self, v: i32) -> Result<Self::Ok, Self::Error> {
  function serialize_i64 (line 319) | fn serialize_i64(self, v: i64) -> Result<Self::Ok, Self::Error> {
  function serialize_i128 (line 328) | fn serialize_i128(self, v: i128) -> Result<Self::Ok, Self::Error> {
  function serialize_u8 (line 337) | fn serialize_u8(self, v: u8) -> Result<Self::Ok, Self::Error> {
  function serialize_u16 (line 346) | fn serialize_u16(self, v: u16) -> Result<Self::Ok, Self::Error> {
  function serialize_u32 (line 355) | fn serialize_u32(self, v: u32) -> Result<Self::Ok, Self::Error> {
  function serialize_u64 (line 364) | fn serialize_u64(self, v: u64) -> Result<Self::Ok, Self::Error> {
  function serialize_u128 (line 373) | fn serialize_u128(self, v: u128) -> Result<Self::Ok, Self::Error> {
  function serialize_f32 (line 382) | fn serialize_f32(self, _v: f32) -> Result<Self::Ok, Self::Error> {
  function serialize_f64 (line 386) | fn serialize_f64(self, _v: f64) -> Result<Self::Ok, Self::Error> {
  function serialize_char (line 390) | fn serialize_char(self, v: char) -> Result<Self::Ok, Self::Error> {
  function serialize_bytes (line 394) | fn serialize_bytes(self, _v: &[u8]) -> Result<Self::Ok, Self::Error> {
  function serialize_none (line 398) | fn serialize_none(self) -> Result<Self::Ok, Self::Error> {
  function serialize_some (line 402) | fn serialize_some<T>(self, _value: &T) -> Result<Self::Ok, Self::Error>
  function serialize_unit (line 409) | fn serialize_unit(self) -> Result<Self::Ok, Self::Error> {
  function serialize_unit_struct (line 413) | fn serialize_unit_struct(self, _name: &'static str) -> Result<Self::Ok, ...
  function serialize_newtype_variant (line 417) | fn serialize_newtype_variant<T>(
  function serialize_seq (line 430) | fn serialize_seq(self, _len: Option<usize>) -> Result<Self::SerializeSeq...
  function serialize_tuple (line 434) | fn serialize_tuple(self, _len: usize) -> Result<Self::SerializeTuple, Se...
  function serialize_tuple_struct (line 438) | fn serialize_tuple_struct(
  function serialize_tuple_variant (line 446) | fn serialize_tuple_variant(
  function serialize_map (line 456) | fn serialize_map(self, _len: Option<usize>) -> Result<Self::SerializeMap...
  function serialize_struct (line 460) | fn serialize_struct(
  function serialize_struct_variant (line 468) | fn serialize_struct_variant(
  type SerializeMap (line 479) | struct SerializeMap<'serializer, W: Write + 'serializer> {
  type Ok (line 488) | type Ok = ();
  type Error (line 489) | type Error = Error;
  function serialize_key (line 491) | fn serialize_key<T>(&mut self, key: &T) -> Result<(), Self::Error>
  function serialize_value (line 513) | fn serialize_value<T>(&mut self, value: &T) -> Result<(), Self::Error>
  function end (line 521) | fn end(self) -> Result<Self::Ok, Self::Error> {
  type Ok (line 535) | type Ok = ();
  type Error (line 536) | type Error = Error;
  function serialize_field (line 538) | fn serialize_field<T>(&mut self, key: &'static str, value: &T) -> Result...
  function end (line 565) | fn end(self) -> Result<Self::Ok, Self::Error> {
  type SerializeStructVariant (line 575) | struct SerializeStructVariant<'serializer, W: Write + 'serializer> {
  type Ok (line 584) | type Ok = ();
  type Error (line 585) | type Error = Error;
  function serialize_field (line 587) | fn serialize_field<T>(&mut self, key: &'static str, value: &T) -> Result...
  function end (line 615) | fn end(self) -> Result<Self::Ok, Self::Error> {
  type Ok (line 633) | type Ok = ();
  type Error (line 634) | type Error = Error;
  type SerializeSeq (line 635) | type SerializeSeq = SerializeSeq<'writer, W>;
  type SerializeTuple (line 636) | type SerializeTuple = SerializeSeq<'writer, W>;
  type SerializeTupleStruct (line 637) | type SerializeTupleStruct = SerializeSeq<'writer, W>;
  type SerializeTupleVariant (line 638) | type SerializeTupleVariant = SerializeSeq<'writer, W>;
  type SerializeMap (line 639) | type SerializeMap = SerializeMap<'writer, W>;
  type SerializeStruct (line 640) | type SerializeStruct = SerializeMap<'writer, W>;
  type SerializeStructVariant (line 641) | type SerializeStructVariant = SerializeStructVariant<'writer, W>;
  function serialize_bool (line 643) | fn serialize_bool(self, v: bool) -> Result<Self::Ok, Self::Error> {
  function serialize_i8 (line 651) | fn serialize_i8(self, v: i8) -> Result<Self::Ok, Self::Error> {
  function serialize_i16 (line 655) | fn serialize_i16(self, v: i16) -> Result<Self::Ok, Self::Error> {
  function serialize_i32 (line 659) | fn serialize_i32(self, v: i32) -> Result<Self::Ok, Self::Error> {
  function serialize_i64 (line 663) | fn serialize_i64(self, v: i64) -> Result<Self::Ok, Self::Error> {
  function serialize_i128 (line 667) | fn serialize_i128(self, v: i128) -> Result<Self::Ok, Self::Error> {
  function serialize_u8 (line 671) | fn serialize_u8(self, v: u8) -> Result<Self::Ok, Self::Error> {
  function serialize_u16 (line 675) | fn serialize_u16(self, v: u16) -> Result<Self::Ok, Self::Error> {
  function serialize_u32 (line 679) | fn serialize_u32(self, v: u32) -> Result<Self::Ok, Self::Error> {
  function serialize_u64 (line 683) | fn serialize_u64(self, v: u64) -> Result<Self::Ok, Self::Error> {
  function serialize_u128 (line 687) | fn serialize_u128(self, v: u128) -> Result<Self::Ok, Self::Error> {
  function serialize_f32 (line 692) | fn serialize_f32(self, v: f32) -> Result<Self::Ok, Self::Error> {
  function serialize_f64 (line 696) | fn serialize_f64(self, v: f64) -> Result<Self::Ok, Self::Error> {
  function serialize_char (line 700) | fn serialize_char(self, v: char) -> Result<Self::Ok, Self::Error> {
  function serialize_str (line 707) | fn serialize_str(self, v: &str) -> Result<Self::Ok, Self::Error> {
  function serialize_bytes (line 711) | fn serialize_bytes(self, v: &[u8]) -> Result<Self::Ok, Self::Error> {
  function serialize_none (line 730) | fn serialize_none(self) -> Result<Self::Ok, Self::Error> {
  function serialize_some (line 734) | fn serialize_some<T>(self, value: &T) -> Result<Self::Ok, Self::Error>
  function serialize_unit (line 741) | fn serialize_unit(self) -> Result<Self::Ok, Self::Error> {
  function serialize_unit_struct (line 745) | fn serialize_unit_struct(self, _name: &'static str) -> Result<Self::Ok, ...
  function serialize_unit_variant (line 749) | fn serialize_unit_variant(
  function serialize_newtype_struct (line 759) | fn serialize_newtype_struct<T>(
  function serialize_newtype_variant (line 771) | fn serialize_newtype_variant<T>(
  function serialize_seq (line 790) | fn serialize_seq(self, len: Option<usize>) -> Result<Self::SerializeSeq,...
  function serialize_tuple (line 804) | fn serialize_tuple(self, len: usize) -> Result<Self::SerializeTuple, Sel...
  function serialize_tuple_struct (line 809) | fn serialize_tuple_struct(
  function serialize_tuple_variant (line 818) | fn serialize_tuple_variant(
  function serialize_map (line 836) | fn serialize_map(self, len: Option<usize>) -> Result<Self::SerializeMap,...
  function serialize_struct (line 850) | fn serialize_struct(
  function serialize_struct_variant (line 859) | fn serialize_struct_variant(
  function pretty_print_serde (line 897) | fn pretty_print_serde() {
  function numerical_map_serde (line 910) | fn numerical_map_serde() {
  function arb_json_value (line 936) | fn arb_json_value() -> BoxedStrategy<Value> {
  function arb_json_value (line 968) | fn arb_json_value() -> BoxedStrategy<Value> {
  function prettyfy (line 1026) | fn prettyfy() {

FILE: src/serde/value/borrowed.rs
  function to_value (line 14) | pub fn to_value<'se, T>(value: T) -> Result<BorrowedValue<'se>>
  function from_value (line 27) | pub fn from_value<'de, T>(value: BorrowedValue<'de>) -> Result<T>
  function from_refvalue (line 40) | pub fn from_refvalue<'de, T>(value: &'de BorrowedValue<'de>) -> Result<T>

FILE: src/serde/value/borrowed/de.rs
  type Error (line 20) | type Error = Error;
  function deserialize_any (line 25) | fn deserialize_any<V>(self, visitor: V) -> Result<V::Value, Error>
  function deserialize_option (line 60) | fn deserialize_option<V>(self, visitor: V) -> Result<V::Value, Error>
  function deserialize_enum (line 72) | fn deserialize_enum<V>(
  function deserialize_newtype_struct (line 106) | fn deserialize_newtype_struct<V>(
  function deserialize_struct (line 118) | fn deserialize_struct<V>(
  type Array (line 145) | struct Array<'de>(std::vec::IntoIter<Value<'de>>);
  type Error (line 150) | type Error = Error;
  function next_element_seed (line 152) | fn next_element_seed<T>(&mut self, seed: T) -> Result<Option<T::Value>, ...
  type ArrayRef (line 162) | struct ArrayRef<'de>(std::slice::Iter<'de, Value<'de>>);
  type Error (line 167) | type Error = Error;
  function next_element_seed (line 169) | fn next_element_seed<T>(&mut self, seed: T) -> Result<Option<T::Value>, ...
  type ObjectAccess (line 179) | struct ObjectAccess<'de, const N: usize = 32> {
  function new (line 185) | fn new(i: halfbrown::IntoIter<Cow<'de, str>, Value<'de>, N>) -> Self {
  type Error (line 193) | type Error = Error;
  function next_key_seed (line 195) | fn next_key_seed<K>(&mut self, seed: K) -> Result<Option<K::Value>, Self...
  function next_value_seed (line 208) | fn next_value_seed<V>(&mut self, seed: V) -> Result<V::Value, Self::Error>
  type ObjectRefAccess (line 219) | struct ObjectRefAccess<'de> {
  function new (line 224) | fn new(i: halfbrown::Iter<'de, Cow<'de, str>, Value<'de>>) -> Self {
  type Error (line 232) | type Error = Error;
  function next_key_seed (line 234) | fn next_key_seed<K>(&mut self, seed: K) -> Result<Option<K::Value>, Self...
  function next_value_seed (line 247) | fn next_value_seed<V>(&mut self, seed: V) -> Result<V::Value, Self::Error>
  function deserialize (line 259) | fn deserialize<D>(deserializer: D) -> Result<Value<'de>, D::Error>
  type ValueVisitor (line 267) | struct ValueVisitor;
    type Value (line 270) | type Value = Value<'de>;
    method expecting (line 272) | fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
    method visit_unit (line 278) | fn visit_unit<E>(self) -> Result<Self::Value, E> {
    method visit_bool (line 284) | fn visit_bool<E>(self, value: bool) -> Result<Self::Value, E> {
    method visit_none (line 290) | fn visit_none<E>(self) -> Result<Self::Value, E> {
    method visit_some (line 295) | fn visit_some<D>(self, deserializer: D) -> Result<Self::Value, D::Error>
    method visit_i8 (line 312) | fn visit_i8<E>(self, value: i8) -> Result<Self::Value, E>
    method visit_i16 (line 320) | fn visit_i16<E>(self, value: i16) -> Result<Self::Value, E>
    method visit_i32 (line 328) | fn visit_i32<E>(self, value: i32) -> Result<Self::Value, E>
    method visit_i64 (line 336) | fn visit_i64<E>(self, value: i64) -> Result<Self::Value, E>
    method visit_i128 (line 345) | fn visit_i128<E>(self, value: i128) -> Result<Self::Value, E>
    method visit_u8 (line 355) | fn visit_u8<E>(self, value: u8) -> Result<Self::Value, E>
    method visit_u16 (line 363) | fn visit_u16<E>(self, value: u16) -> Result<Self::Value, E>
    method visit_u32 (line 371) | fn visit_u32<E>(self, value: u32) -> Result<Self::Value, E>
    method visit_u64 (line 379) | fn visit_u64<E>(self, value: u64) -> Result<Self::Value, E>
    method visit_u128 (line 388) | fn visit_u128<E>(self, value: u128) -> Result<Self::Value, E>
    method visit_f32 (line 398) | fn visit_f32<E>(self, value: f32) -> Result<Self::Value, E>
    method visit_f64 (line 406) | fn visit_f64<E>(self, value: f64) -> Result<Self::Value, E>
    method visit_char (line 415) | fn visit_char<E>(self, value: char) -> Result<Self::Value, E>
    method visit_borrowed_str (line 423) | fn visit_borrowed_str<E>(self, value: &'de str) -> Result<Self::Value, E>
    method visit_str (line 431) | fn visit_str<E>(self, value: &str) -> Result<Self::Value, E>
    method visit_string (line 439) | fn visit_string<E>(self, value: String) -> Result<Self::Value, E>
    method visit_map (line 476) | fn visit_map<A>(self, mut map: A) -> Result<Self::Value, A::Error>
    method visit_seq (line 491) | fn visit_seq<A>(self, mut seq: A) -> Result<Self::Value, A::Error>
  type EnumDeserializer (line 505) | struct EnumDeserializer<'de> {
  type Error (line 511) | type Error = Error;
  type Variant (line 512) | type Variant = VariantDeserializer<'de>;
  function variant_seed (line 514) | fn variant_seed<V>(self, seed: V) -> Result<(V::Value, VariantDeserializ...
  type Deserializer (line 525) | type Deserializer = Self;
  function into_deserializer (line 527) | fn into_deserializer(self) -> Self::Deserializer {
  type VariantDeserializer (line 532) | struct VariantDeserializer<'de> {
  type Error (line 537) | type Error = Error;
  function unit_variant (line 539) | fn unit_variant(self) -> Result<(), Error> {
  function newtype_variant_seed (line 546) | fn newtype_variant_seed<T>(self, seed: T) -> Result<T::Value, Error>
  function tuple_variant (line 559) | fn tuple_variant<V>(self, _len: usize, visitor: V) -> Result<V::Value, E...
  function struct_variant (line 582) | fn struct_variant<V>(
  type Error (line 605) | type Error = Error;
  function deserialize_any (line 610) | fn deserialize_any<V>(self, visitor: V) -> Result<V::Value, Error>
  function deserialize_option (line 632) | fn deserialize_option<V>(self, visitor: V) -> Result<V::Value, Error>
  function deserialize_newtype_struct (line 643) | fn deserialize_newtype_struct<V>(
  function deserialize_struct (line 655) | fn deserialize_struct<V>(
  function deserialize_enum (line 676) | fn deserialize_enum<V>(
  type EnumRefDeserializer (line 716) | struct EnumRefDeserializer<'de> {
  type Error (line 722) | type Error = Error;
  type Variant (line 723) | type Variant = VariantRefDeserializer<'de>;
  function variant_seed (line 726) | fn variant_seed<V>(self, seed: V) -> Result<(V::Value, Self::Variant), E...
  function variant_seed (line 735) | fn variant_seed<V>(self, seed: V) -> Result<(V::Value, Self::Variant), E...
  type VariantRefDeserializer (line 745) | struct VariantRefDeserializer<'de> {
  type Error (line 750) | type Error = Error;
  function unit_variant (line 752) | fn unit_variant(self) -> Result<(), Error> {
  function newtype_variant_seed (line 759) | fn newtype_variant_seed<T>(self, seed: T) -> Result<T::Value, Error>
  function tuple_variant (line 772) | fn tuple_variant<V>(self, _len: usize, visitor: V) -> Result<V::Value, E...
  function struct_variant (line 795) | fn struct_variant<V>(
  function option_field_absent_owned (line 824) | fn option_field_absent_owned() {
  function option_field_present_owned (line 845) | fn option_field_present_owned() {
  function deserialize (line 876) | fn deserialize() {
  function deserialize_128bit (line 939) | fn deserialize_128bit() {
  function variant (line 952) | fn variant() {

FILE: src/serde/value/borrowed/se.rs
  type Impossible (line 14) | type Impossible<T> = ser::Impossible<T, Error>;
  method serialize (line 17) | fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::E...
  type Serializer (line 52) | pub struct Serializer<'se> {
  method default (line 57) | fn default() -> Self {
  type Ok (line 65) | type Ok = Value<'se>;
  type Error (line 66) | type Error = Error;
  type SerializeSeq (line 68) | type SerializeSeq = SerializeVec<'se>;
  type SerializeTuple (line 69) | type SerializeTuple = SerializeVec<'se>;
  type SerializeTupleStruct (line 70) | type SerializeTupleStruct = SerializeVec<'se>;
  type SerializeTupleVariant (line 71) | type SerializeTupleVariant = SerializeTupleVariant<'se>;
  type SerializeMap (line 72) | type SerializeMap = SerializeMap<'se>;
  type SerializeStruct (line 73) | type SerializeStruct = SerializeMap<'se>;
  type SerializeStructVariant (line 74) | type SerializeStructVariant = SerializeStructVariant<'se>;
  function serialize_bool (line 77) | fn serialize_bool(self, value: bool) -> Result<Value<'se>> {
  function serialize_i8 (line 82) | fn serialize_i8(self, value: i8) -> Result<Value<'se>> {
  function serialize_i16 (line 87) | fn serialize_i16(self, value: i16) -> Result<Value<'se>> {
  function serialize_i32 (line 92) | fn serialize_i32(self, value: i32) -> Result<Value<'se>> {
  function serialize_i64 (line 96) | fn serialize_i64(self, value: i64) -> Result<Value<'se>> {
  function serialize_i128 (line 101) | fn serialize_i128(self, value: i128) -> Result<Value<'se>> {
  function serialize_u8 (line 106) | fn serialize_u8(self, value: u8) -> Result<Value<'se>> {
  function serialize_u16 (line 111) | fn serialize_u16(self, value: u16) -> Result<Value<'se>> {
  function serialize_u32 (line 116) | fn serialize_u32(self, value: u32) -> Result<Value<'se>> {
  function serialize_u64 (line 121) | fn serialize_u64(self, value: u64) -> Result<Value<'se>> {
  function serialize_u128 (line 126) | fn serialize_u128(self, value: u128) -> Result<Value<'se>> {
  function serialize_f32 (line 131) | fn serialize_f32(self, value: f32) -> Result<Value<'se>> {
  function serialize_f64 (line 136) | fn serialize_f64(self, value: f64) -> Result<Value<'se>> {
  function serialize_char (line 141) | fn serialize_char(self, value: char) -> Result<Value<'se>> {
  function serialize_str (line 148) | fn serialize_str(self, value: &str) -> Result<Value<'se>> {
  function serialize_bytes (line 153) | fn serialize_bytes(self, value: &[u8]) -> Result<Value<'se>> {
  function serialize_unit (line 158) | fn serialize_unit(self) -> Result<Value<'se>> {
  function serialize_unit_struct (line 163) | fn serialize_unit_struct(self, _name: &'static str) -> Result<Value<'se>> {
  function serialize_unit_variant (line 168) | fn serialize_unit_variant(
  function serialize_newtype_struct (line 178) | fn serialize_newtype_struct<T>(self, _name: &'static str, value: &T) -> ...
  function serialize_newtype_variant (line 185) | fn serialize_newtype_variant<T>(
  function serialize_none (line 202) | fn serialize_none(self) -> Result<Value<'se>> {
  function serialize_some (line 207) | fn serialize_some<T>(self, value: &T) -> Result<Value<'se>>
  function serialize_seq (line 214) | fn serialize_seq(self, len: Option<usize>) -> Result<Self::SerializeSeq> {
  function serialize_tuple (line 220) | fn serialize_tuple(self, len: usize) -> Result<Self::SerializeTuple> {
  function serialize_tuple_struct (line 224) | fn serialize_tuple_struct(
  function serialize_tuple_variant (line 232) | fn serialize_tuple_variant(
  function serialize_map (line 245) | fn serialize_map(self, len: Option<usize>) -> Result<Self::SerializeMap> {
  function serialize_struct (line 252) | fn serialize_struct(self, _name: &'static str, len: usize) -> Result<Sel...
  function serialize_struct_variant (line 256) | fn serialize_struct_variant(
  type SerializeVec (line 270) | pub struct SerializeVec<'se> {
  type SerializeTupleVariant (line 274) | pub struct SerializeTupleVariant<'se> {
  type SerializeMap (line 279) | pub struct SerializeMap<'se> {
  type SerializeStructVariant (line 284) | pub struct SerializeStructVariant<'se> {
  type Ok (line 290) | type Ok = Value<'se>;
  type Error (line 291) | type Error = Error;
  function serialize_element (line 293) | fn serialize_element<T>(&mut self, value: &T) -> Result<()>
  function end (line 301) | fn end(self) -> Result<Value<'se>> {
  type Ok (line 307) | type Ok = Value<'se>;
  type Error (line 308) | type Error = Error;
  function serialize_element (line 310) | fn serialize_element<T>(&mut self, value: &T) -> Result<()>
  function end (line 317) | fn end(self) -> Result<Value<'se>> {
  type Ok (line 323) | type Ok = Value<'se>;
  type Error (line 324) | type Error = Error;
  function serialize_field (line 326) | fn serialize_field<T>(&mut self, value: &T) -> Result<()>
  function end (line 333) | fn end(self) -> Result<Value<'se>> {
  type Ok (line 339) | type Ok = Value<'se>;
  type Error (line 340) | type Error = Error;
  function serialize_field (line 342) | fn serialize_field<T>(&mut self, value: &T) -> Result<()>
  function end (line 350) | fn end(self) -> Result<Value<'se>> {
  type Ok (line 359) | type Ok = Value<'se>;
  type Error (line 360) | type Error = Error;
  function serialize_key (line 362) | fn serialize_key<T>(&mut self, key: &T) -> Result<()>
  function serialize_value (line 372) | fn serialize_value<T>(&mut self, value: &T) -> Result<()>
  function end (line 384) | fn end(self) -> Result<Value<'se>> {
  type MapKeySerializer (line 389) | struct MapKeySerializer<'se> {
  function key_must_be_a_string (line 393) | fn key_must_be_a_string() -> Error {
  type Ok (line 398) | type Ok = Cow<'se, str>;
  type Error (line 399) | type Error = Error;
  type SerializeSeq (line 401) | type SerializeSeq = Impossible<Cow<'se, str>>;
  type SerializeTuple (line 402) | type SerializeTuple = Impossible<Cow<'se, str>>;
  type SerializeTupleStruct (line 403) | type SerializeTupleStruct = Impossible<Cow<'se, str>>;
  type SerializeTupleVariant (line 404) | type SerializeTupleVariant = Impossible<Cow<'se, str>>;
  type SerializeMap (line 405) | type SerializeMap = Impossible<Cow<'se, str>>;
  type SerializeStruct (line 406) | type SerializeStruct = Impossible<Cow<'se, str>>;
  type SerializeStructVariant (line 407) | type SerializeStructVariant = Impossible<Cow<'se, str>>;
  function serialize_unit_variant (line 410) | fn serialize_unit_variant(
  function serialize_newtype_struct (line 420) | fn serialize_newtype_struct<T>(self, _name: &'static str, value: &T) -> ...
  function serialize_bool (line 427) | fn serialize_bool(self, _value: bool) -> Result<Self::Ok> {
  function serialize_i8 (line 431) | fn serialize_i8(self, value: i8) -> Result<Self::Ok> {
  function serialize_i16 (line 435) | fn serialize_i16(self, value: i16) -> Result<Self::Ok> {
  function serialize_i32 (line 439) | fn serialize_i32(self, value: i32) -> Result<Self::Ok> {
  function serialize_i64 (line 443) | fn serialize_i64(self, value: i64) -> Result<Self::Ok> {
  function serialize_u8 (line 447) | fn serialize_u8(self, value: u8) -> Result<Self::Ok> {
  function serialize_u16 (line 451) | fn serialize_u16(self, value: u16) -> Result<Self::Ok> {
  function serialize_u32 (line 455) | fn serialize_u32(self, value: u32) -> Result<Self::Ok> {
  function serialize_u64 (line 459) | fn serialize_u64(self, value: u64) -> Result<Self::Ok> {
  function serialize_f32 (line 463) | fn serialize_f32(self, _value: f32) -> Result<Self::Ok> {
  function serialize_f64 (line 467) | fn serialize_f64(self, _value: f64) -> Result<Self::Ok> {
  function serialize_char (line 471) | fn serialize_char(self, value: char) -> Result<Self::Ok> {
  function serialize_str (line 480) | fn serialize_str(self, value: &str) -> Result<Self::Ok> {
  function serialize_bytes (line 485) | fn serialize_bytes(self, _value: &[u8]) -> Result<Self::Ok> {
  function serialize_unit (line 489) | fn serialize_unit(self) -> Result<Self::Ok> {
  function serialize_unit_struct (line 493) | fn serialize_unit_struct(self, _name: &'static str) -> Result<Self::Ok> {
  function serialize_newtype_variant (line 497) | fn serialize_newtype_variant<T>(
  function serialize_none (line 510) | fn serialize_none(self) -> Result<Self::Ok> {
  function serialize_some (line 514) | fn serialize_some<T>(self, _value: &T) -> Result<Self::Ok>
  function serialize_seq (line 521) | fn serialize_seq(self, _len: Option<usize>) -> Result<Self::SerializeSeq> {
  function serialize_tuple (line 525) | fn serialize_tuple(self, _len: usize) -> Result<Self::SerializeTuple> {
  function serialize_tuple_struct (line 529) | fn serialize_tuple_struct(
  function serialize_tuple_variant (line 537) | fn serialize_tuple_variant(
  function serialize_map (line 547) | fn serialize_map(self, _len: Option<usize>) -> Result<Self::SerializeMap> {
  function serialize_struct (line 551) | fn serialize_struct(self, _name: &'static str, _len: usize) -> Result<Se...
  function serialize_struct_variant (line 555) | fn serialize_struct_variant(
  type Ok (line 567) | type Ok = Value<'se>;
  type Error (line 568) | type Error = Error;
  function serialize_field (line 570) | fn serialize_field<T>(&mut self, key: &'static str, value: &T) -> Result...
  function end (line 578) | fn end(self) -> Result<Value<'se>> {
  type Ok (line 584) | type Ok = Value<'se>;
  type Error (line 585) | type Error = Error;
  function serialize_field (line 587) | fn serialize_field<T>(&mut self, key: &'static str, value: &T) -> Result...
  function end (line 595) | fn end(self) -> Result<Value<'se>> {
  function null (line 611) | fn null() {
  function bool_true (line 618) | fn bool_true() {
  function bool_false (line 625) | fn bool_false() {
  function float (line 632) | fn float() {
  function stringlike (line 639) | fn stringlike() {
  function int (line 650) | fn int() {
  function arr (line 657) | fn arr() {
  function map (line 667) | fn map() {
  type Map (line 678) | struct Map {
  type Obj (line 683) | struct Obj {
  function from_slice_to_object (line 705) | fn from_slice_to_object() {

FILE: src/serde/value/owned.rs
  function to_value (line 15) | pub fn to_value<T>(value: T) -> Result<OwnedValue>
  function from_value (line 28) | pub fn from_value<T>(value: OwnedValue) -> Result<T>
  function from_refvalue (line 41) | pub fn from_refvalue<T>(value: &OwnedValue) -> Result<T>

FILE: src/serde/value/owned/de.rs
  type Error (line 19) | type Error = Error;
  method deserialize_any (line 24) | fn deserialize_any<V>(self, visitor: V) -> Result<V::Value, Error>
  method deserialize_option (line 49) | fn deserialize_option<V>(self, visitor: V) -> Result<V::Value, Error>
  method deserialize_enum (line 60) | fn deserialize_enum<V>(
  method deserialize_newtype_struct (line 94) | fn deserialize_newtype_struct<V>(
  method deserialize_struct (line 106) | fn deserialize_struct<V>(
  type Array (line 133) | struct Array(std::vec::IntoIter<Value>);
    type Error (line 138) | type Error = Error;
    method next_element_seed (line 140) | fn next_element_seed<T>(&mut self, seed: T) -> Result<Option<T::Value>...
  type ArrayRef (line 150) | struct ArrayRef<'de>(std::slice::Iter<'de, Value>);
  type Error (line 155) | type Error = Error;
  function next_element_seed (line 157) | fn next_element_seed<T>(&mut self, seed: T) -> Result<Option<T::Value>, ...
  type ObjectAccess (line 167) | struct ObjectAccess<const N: usize = 32> {
    type Error (line 180) | type Error = Error;
    method next_key_seed (line 182) | fn next_key_seed<K>(&mut self, seed: K) -> Result<Option<K::Value>, Se...
    method next_value_seed (line 195) | fn next_value_seed<V>(&mut self, seed: V) -> Result<V::Value, Self::Er...
  function new (line 173) | fn new(i: halfbrown::IntoIter<String, Value, N>) -> Self {
  type ObjectRefAccess (line 206) | struct ObjectRefAccess<'de> {
  function new (line 212) | fn new(i: halfbrown::Iter<'de, String, Value>) -> Self {
  type Error (line 220) | type Error = Error;
  function next_key_seed (line 222) | fn next_key_seed<K>(&mut self, seed: K) -> Result<Option<K::Value>, Self...
  function next_value_seed (line 234) | fn next_value_seed<V>(&mut self, seed: V) -> Result<V::Value, Self::Error>
  method deserialize (line 246) | fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
  type ValueVisitor (line 254) | struct ValueVisitor;
    type Value (line 257) | type Value = Value;
    method expecting (line 259) | fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
    method visit_unit (line 265) | fn visit_unit<E>(self) -> Result<Self::Value, E> {
    method visit_bool (line 271) | fn visit_bool<E>(self, value: bool) -> Result<Self::Value, E> {
    method visit_none (line 277) | fn visit_none<E>(self) -> Result<Self::Value, E> {
    method visit_some (line 282) | fn visit_some<D>(self, deserializer: D) -> Result<Self::Value, D::Error>
    method visit_i8 (line 299) | fn visit_i8<E>(self, value: i8) -> Result<Self::Value, E>
    method visit_i16 (line 307) | fn visit_i16<E>(self, value: i16) -> Result<Self::Value, E>
    method visit_i32 (line 315) | fn visit_i32<E>(self, value: i32) -> Result<Self::Value, E>
    method visit_i64 (line 323) | fn visit_i64<E>(self, value: i64) -> Result<Self::Value, E>
    method visit_i128 (line 332) | fn visit_i128<E>(self, value: i128) -> Result<Self::Value, E>
    method visit_u8 (line 342) | fn visit_u8<E>(self, value: u8) -> Result<Self::Value, E>
    method visit_u16 (line 350) | fn visit_u16<E>(self, value: u16) -> Result<Self::Value, E>
    method visit_u32 (line 358) | fn visit_u32<E>(self, value: u32) -> Result<Self::Value, E>
    method visit_u64 (line 366) | fn visit_u64<E>(self, value: u64) -> Result<Self::Value, E>
    method visit_u128 (line 375) | fn visit_u128<E>(self, value: u128) -> Result<Self::Value, E>
    method visit_f32 (line 384) | fn visit_f32<E>(self, value: f32) -> Result<Self::Value, E>
    method visit_f64 (line 392) | fn visit_f64<E>(self, value: f64) -> Result<Self::Value, E>
    method visit_char (line 401) | fn visit_char<E>(self, value: char) -> Result<Self::Value, E>
    method visit_borrowed_str (line 409) | fn visit_borrowed_str<E>(self, value: &'de str) -> Result<Self::Value, E>
    method visit_str (line 417) | fn visit_str<E>(self, value: &str) -> Result<Self::Value, E>
    method visit_string (line 425) | fn visit_string<E>(self, value: String) -> Result<Self::Value, E>
    method visit_map (line 463) | fn visit_map<A>(self, mut map: A) -> Result<Self::Value, A::Error>
    method visit_seq (line 478) | fn visit_seq<A>(self, mut seq: A) -> Result<Self::Value, A::Error>
  type EnumDeserializer (line 492) | struct EnumDeserializer {
    type Error (line 498) | type Error = Error;
    type Variant (line 499) | type Variant = VariantDeserializer;
    method variant_seed (line 501) | fn variant_seed<V>(self, seed: V) -> Result<(V::Value, VariantDeserial...
  type Deserializer (line 512) | type Deserializer = Self;
  method into_deserializer (line 514) | fn into_deserializer(self) -> Self::Deserializer {
  type VariantDeserializer (line 519) | struct VariantDeserializer {
    type Error (line 524) | type Error = Error;
    method unit_variant (line 526) | fn unit_variant(self) -> Result<(), Error> {
    method newtype_variant_seed (line 533) | fn newtype_variant_seed<T>(self, seed: T) -> Result<T::Value, Error>
    method tuple_variant (line 546) | fn tuple_variant<V>(self, _len: usize, visitor: V) -> Result<V::Value,...
    method struct_variant (line 569) | fn struct_variant<V>(
  type Error (line 592) | type Error = Error;
  function deserialize_any (line 597) | fn deserialize_any<V>(self, visitor: V) -> Result<V::Value, Error>
  function deserialize_option (line 619) | fn deserialize_option<V>(self, visitor: V) -> Result<V::Value, Error>
  function deserialize_newtype_struct (line 631) | fn deserialize_newtype_struct<V>(
  function deserialize_struct (line 643) | fn deserialize_struct<V>(
  function deserialize_enum (line 664) | fn deserialize_enum<V>(
  type EnumRefDeserializer (line 704) | struct EnumRefDeserializer<'de> {
  type Error (line 710) | type Error = Error;
  type Variant (line 711) | type Variant = VariantRefDeserializer<'de>;
  function variant_seed (line 713) | fn variant_seed<V>(self, seed: V) -> Result<(V::Value, Self::Variant), E...
  type VariantRefDeserializer (line 722) | struct VariantRefDeserializer<'de> {
  type Error (line 727) | type Error = Error;
  function unit_variant (line 729) | fn unit_variant(self) -> Result<(), Error> {
  function newtype_variant_seed (line 736) | fn newtype_variant_seed<T>(self, seed: T) -> Result<T::Value, Error>
  function tuple_variant (line 749) | fn tuple_variant<V>(self, _len: usize, visitor: V) -> Result<V::Value, E...
  function struct_variant (line 772) | fn struct_variant<V>(
  function option_field_absent_owned (line 800) | fn option_field_absent_owned() {
  function option_field_present_owned (line 820) | fn option_field_present_owned() {
  function deserialize (line 849) | fn deserialize() {
  function deserialize_128bit (line 914) | fn deserialize_128bit() {
  function variant (line 926) | fn variant() {

FILE: src/serde/value/owned/se.rs
  type Impossible (line 11) | type Impossible<T> = ser::Impossible<T, Error>;
  method serialize (line 14) | fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::E...
  type Serializer (line 49) | pub struct Serializer {}
    type Ok (line 52) | type Ok = Value;
    type Error (line 53) | type Error = Error;
    type SerializeSeq (line 55) | type SerializeSeq = SerializeVec;
    type SerializeTuple (line 56) | type SerializeTuple = SerializeVec;
    type SerializeTupleStruct (line 57) | type SerializeTupleStruct = SerializeVec;
    type SerializeTupleVariant (line 58) | type SerializeTupleVariant = SerializeTupleVariant;
    type SerializeMap (line 59) | type SerializeMap = SerializeMap;
    type SerializeStruct (line 60) | type SerializeStruct = SerializeMap;
    type SerializeStructVariant (line 61) | type SerializeStructVariant = SerializeStructVariant;
    method serialize_bool (line 64) | fn serialize_bool(self, value: bool) -> Result<Value> {
    method serialize_i8 (line 69) | fn serialize_i8(self, value: i8) -> Result<Value> {
    method serialize_i16 (line 74) | fn serialize_i16(self, value: i16) -> Result<Value> {
    method serialize_i32 (line 79) | fn serialize_i32(self, value: i32) -> Result<Value> {
    method serialize_i64 (line 83) | fn serialize_i64(self, value: i64) -> Result<Value> {
    method serialize_i128 (line 88) | fn serialize_i128(self, value: i128) -> Result<Value> {
    method serialize_u8 (line 93) | fn serialize_u8(self, value: u8) -> Result<Value> {
    method serialize_u16 (line 98) | fn serialize_u16(self, value: u16) -> Result<Value> {
    method serialize_u32 (line 103) | fn serialize_u32(self, value: u32) -> Result<Value> {
    method serialize_u64 (line 108) | fn serialize_u64(self, value: u64) -> Result<Value> {
    method serialize_u128 (line 113) | fn serialize_u128(self, value: u128) -> Result<Value> {
    method serialize_f32 (line 118) | fn serialize_f32(self, value: f32) -> Result<Value> {
    method serialize_f64 (line 123) | fn serialize_f64(self, value: f64) -> Result<Value> {
    method serialize_char (line 128) | fn serialize_char(self, value: char) -> Result<Value> {
    method serialize_str (line 135) | fn serialize_str(self, value: &str) -> Result<Value> {
    method serialize_bytes (line 140) | fn serialize_bytes(self, value: &[u8]) -> Result<Value> {
    method serialize_unit (line 145) | fn serialize_unit(self) -> Result<Value> {
    method serialize_unit_struct (line 150) | fn serialize_unit_struct(self, _name: &'static str) -> Result<Value> {
    method serialize_unit_variant (line 155) | fn serialize_unit_variant(
    method serialize_newtype_struct (line 165) | fn serialize_newtype_struct<T>(self, _name: &'static str, value: &T) -...
    method serialize_newtype_variant (line 172) | fn serialize_newtype_variant<T>(
    method serialize_none (line 188) | fn serialize_none(self) -> Result<Value> {
    method serialize_some (line 193) | fn serialize_some<T>(self, value: &T) -> Result<Value>
    method serialize_seq (line 200) | fn serialize_seq(self, len: Option<usize>) -> Result<Self::SerializeSe...
    method serialize_tuple (line 206) | fn serialize_tuple(self, len: usize) -> Result<Self::SerializeTuple> {
    method serialize_tuple_struct (line 210) | fn serialize_tuple_struct(
    method serialize_tuple_variant (line 218) | fn serialize_tuple_variant(
    method serialize_map (line 231) | fn serialize_map(self, len: Option<usize>) -> Result<Self::SerializeMa...
    method serialize_struct (line 238) | fn serialize_struct(self, _name: &'static str, len: usize) -> Result<S...
    method serialize_struct_variant (line 242) | fn serialize_struct_variant(
  type SerializeVec (line 256) | pub struct SerializeVec {
    type Ok (line 276) | type Ok = Value;
    type Error (line 277) | type Error = Error;
    method serialize_element (line 279) | fn serialize_element<T>(&mut self, value: &T) -> Result<()>
    method end (line 287) | fn end(self) -> Result<Value> {
    type Ok (line 293) | type Ok = Value;
    type Error (line 294) | type Error = Error;
    method serialize_element (line 296) | fn serialize_element<T>(&mut self, value: &T) -> Result<()>
    method end (line 303) | fn end(self) -> Result<Value> {
    type Ok (line 309) | type Ok = Value;
    type Error (line 310) | type Error = Error;
    method serialize_field (line 312) | fn serialize_field<T>(&mut self, value: &T) -> Result<()>
    method end (line 319) | fn end(self) -> Result<Value> {
  type SerializeTupleVariant (line 260) | pub struct SerializeTupleVariant {
    type Ok (line 325) | type Ok = Value;
    type Error (line 326) | type Error = Error;
    method serialize_field (line 328) | fn serialize_field<T>(&mut self, value: &T) -> Result<()>
    method end (line 336) | fn end(self) -> Result<Value> {
  type SerializeMap (line 265) | pub struct SerializeMap {
    type Ok (line 344) | type Ok = Value;
    type Error (line 345) | type Error = Error;
    method serialize_key (line 347) | fn serialize_key<T>(&mut self, key: &T) -> Result<()>
    method serialize_value (line 355) | fn serialize_value<T>(&mut self, value: &T) -> Result<()>
    method end (line 367) | fn end(self) -> Result<Value> {
    type Ok (line 547) | type Ok = Value;
    type Error (line 548) | type Error = Error;
    method serialize_field (line 550) | fn serialize_field<T>(&mut self, key: &'static str, value: &T) -> Resu...
    method end (line 558) | fn end(self) -> Result<Value> {
  type SerializeStructVariant (line 270) | pub struct SerializeStructVariant {
    type Ok (line 564) | type Ok = Value;
    type Error (line 565) | type Error = Error;
    method serialize_field (line 567) | fn serialize_field<T>(&mut self, key: &'static str, value: &T) -> Resu...
    method end (line 575) | fn end(self) -> Result<Value> {
  type MapKeySerializer (line 372) | struct MapKeySerializer {}
    type Ok (line 379) | type Ok = String;
    type Error (line 380) | type Error = Error;
    type SerializeSeq (line 382) | type SerializeSeq = Impossible<String>;
    type SerializeTuple (line 383) | type SerializeTuple = Impossible<String>;
    type SerializeTupleStruct (line 384) | type SerializeTupleStruct = Impossible<String>;
    type SerializeTupleVariant (line 385) | type SerializeTupleVariant = Impossible<String>;
    type SerializeMap (line 386) | type SerializeMap = Impossible<String>;
    type SerializeStruct (line 387) | type SerializeStruct = Impossible<String>;
    type SerializeStructVariant (line 388) | type SerializeStructVariant = Impossible<String>;
    method serialize_unit_variant (line 391) | fn serialize_unit_variant(
    method serialize_newtype_struct (line 401) | fn serialize_newtype_struct<T>(self, _name: &'static str, value: &T) -...
    method serialize_bool (line 408) | fn serialize_bool(self, _value: bool) -> Result<Self::Ok> {
    method serialize_i8 (line 412) | fn serialize_i8(self, value: i8) -> Result<Self::Ok> {
    method serialize_i16 (line 416) | fn serialize_i16(self, value: i16) -> Result<Self::Ok> {
    method serialize_i32 (line 420) | fn serialize_i32(self, value: i32) -> Result<Self::Ok> {
    method serialize_i64 (line 424) | fn serialize_i64(self, value: i64) -> Result<Self::Ok> {
    method serialize_u8 (line 428) | fn serialize_u8(self, value: u8) -> Result<Self::Ok> {
    method serialize_u16 (line 432) | fn serialize_u16(self, value: u16) -> Result<Self::Ok> {
    method serialize_u32 (line 436) | fn serialize_u32(self, value: u32) -> Result<Self::Ok> {
    method serialize_u64 (line 440) | fn serialize_u64(self, value: u64) -> Result<Self::Ok> {
    method serialize_f32 (line 444) | fn serialize_f32(self, _value: f32) -> Result<Self::Ok> {
    method serialize_f64 (line 448) | fn serialize_f64(self, _value: f64) -> Result<Self::Ok> {
    method serialize_char (line 452) | fn serialize_char(self, value: char) -> Result<Self::Ok> {
    method serialize_str (line 461) | fn serialize_str(self, value: &str) -> Result<Self::Ok> {
    method serialize_bytes (line 465) | fn serialize_bytes(self, _value: &[u8]) -> Result<Self::Ok> {
    method serialize_unit (line 469) | fn serialize_unit(self) -> Result<Self::Ok> {
    method serialize_unit_struct (line 473) | fn serialize_unit_struct(self, _name: &'static str) -> Result<Self::Ok> {
    method serialize_newtype_variant (line 477) | fn serialize_newtype_variant<T>(
    method serialize_none (line 490) | fn serialize_none(self) -> Result<Self::Ok> {
    method serialize_some (line 494) | fn serialize_some<T>(self, _value: &T) -> Result<Self::Ok>
    method serialize_seq (line 501) | fn serialize_seq(self, _len: Option<usize>) -> Result<Self::SerializeS...
    method serialize_tuple (line 505) | fn serialize_tuple(self, _len: usize) -> Result<Self::SerializeTuple> {
    method serialize_tuple_struct (line 509) | fn serialize_tuple_struct(
    method serialize_tuple_variant (line 517) | fn serialize_tuple_variant(
    method serialize_map (line 527) | fn serialize_map(self, _len: Option<usize>) -> Result<Self::SerializeM...
    method serialize_struct (line 531) | fn serialize_struct(self, _name: &'static str, _len: usize) -> Result<...
    method serialize_struct_variant (line 535) | fn serialize_struct_variant(
  function key_must_be_a_string (line 374) | fn key_must_be_a_string() -> Error {
  type UnitStruct (line 591) | struct UnitStruct;
  type TupleStruct (line 596) | struct TupleStruct(u8, u8);
  type TestStruct (line 598) | struct TestStruct {
  type Obj (line 621) | struct Obj {
  function from_slice_to_object (line 647) | fn from_slice_to_object() {

FILE: src/serde/value/shared.rs
  type MapKeyDeserializer (line 33) | pub(crate) struct MapKeyDeserializer<'de> {
  function borrowed (line 38) | pub(crate) fn borrowed(key: &'de str) -> Self {
  type Error (line 46) | type Error = Error;
  function deserialize_any (line 48) | fn deserialize_any<V>(self, visitor: V) -> Result<V::Value, Self::Error>
  function deserialize_option (line 69) | fn deserialize_option<V>(self, visitor: V) -> Result<V::Value, Self::Error>
  function deserialize_newtype_struct (line 78) | fn deserialize_newtype_struct<V>(
  function deserialize_enum (line 89) | fn deserialize_enum<V>(
  type BorrowedCowStrDeserializer (line 109) | struct BorrowedCowStrDeserializer<'de> {
  function new (line 114) | fn new(value: Cow<'de, str>) -> Self {
  type Error (line 120) | type Error = Error;
  function deserialize_any (line 123) | fn deserialize_any<V>(self, visitor: V) -> Result<V::Value, Self::Error>
  function deserialize_any (line 134) | fn deserialize_any<V>(self, visitor: V) -> Result<V::Value, Self::Error>
  function deserialize_enum (line 144) | fn deserialize_enum<V>(
  type UnitOnly (line 162) | struct UnitOnly;
    type Error (line 165) | type Error = Error;
    method unit_variant (line 167) | fn unit_variant(self) -> Result<(), Self::Error> {
    method newtype_variant_seed (line 171) | fn newtype_variant_seed<T>(self, _seed: T) -> Result<T::Value, Self::E...
    method tuple_variant (line 181) | fn tuple_variant<V>(self, _len: usize, _visitor: V) -> Result<V::Value...
    method struct_variant (line 191) | fn struct_variant<V>(
  type Error (line 207) | type Error = Error;
  type Variant (line 208) | type Variant = UnitOnly;
  function variant_seed (line 210) | fn variant_seed<T>(self, seed: T) -> Result<(T::Value, Self::Variant), S...

FILE: src/stage2.rs
  function is_valid_true_atom (line 10) | pub fn is_valid_true_atom(loc: &[u8]) -> bool {
  function is_valid_false_atom (line 34) | pub fn is_valid_false_atom(loc: &[u8]) -> bool {
  function is_valid_null_atom (line 59) | pub fn is_valid_null_atom(loc: &[u8]) -> bool {
  type State (line 79) | enum State {
  type StackState (line 85) | pub(crate) enum StackState {
  function build_tape (line 99) | pub(crate) fn build_tape(
  function true_atom (line 622) | fn true_atom() {
  function false_atom (line 628) | fn false_atom() {
  function null_atom (line 639) | fn null_atom() {
  function parsing_errors (line 647) | fn parsing_errors() {
  function parse_string (line 687) | fn parse_string() -> Result<()> {

FILE: src/stringparse.rs
  constant ESCAPE_MAP (line 11) | pub(crate) const ESCAPE_MAP: [u8; 256] = [
  constant HIGH_SURROGATES (line 25) | const HIGH_SURROGATES: Range<u32> = 0xd800..0xdc00;
  constant LOW_SURROGATES (line 26) | const LOW_SURROGATES: Range<u32> = 0xdc00..0xe000;
  function handle_unicode_codepoint (line 32) | pub(crate) fn handle_unicode_codepoint(
  function get_unicode_codepoint (line 48) | pub(crate) fn get_unicode_codepoint(mut src_ptr: &[u8]) -> Result<(u32, ...

FILE: src/tests.rs
  function alligned_number_parse (line 18) | fn alligned_number_parse() {
  function test_send_sync (line 27) | fn test_send_sync() {
  function count1 (line 34) | fn count1() {
  function count2 (line 42) | fn count2() {
  function count3 (line 50) | fn count3() {
  function count4 (line 58) | fn count4() {
  function count5 (line 67) | fn count5() {
  function test_tape_object_simple (line 76) | fn test_tape_object_simple() {
  function test_tape_object_escaped (line 93) | fn test_tape_object_escaped() {
  function string_array (line 113) | fn string_array() {
  function odd_nuber (line 123) | fn odd_nuber() {
  function odd_nuber2 (line 141) | fn odd_nuber2() {
  function silly_float1 (line 160) | fn silly_float1() {
  function silly_float2 (line 170) | fn silly_float2() {
  function arb_json_value (line 179) | fn arb_json_value() -> BoxedStrategy<Value> {
  function arb_json_value (line 205) | fn arb_json_value() -> BoxedStrategy<Value> {

FILE: src/tests/impls.rs
  function test_find_structural_bits (line 3) | fn test_find_structural_bits<S: Stage1Parse>(input_str: &str, expected: ...
  function find_structural_bits_test_cases (line 16) | fn find_structural_bits_test_cases<S: Stage1Parse>() {
  function find_structural_bits_native (line 43) | fn find_structural_bits_native() {
  function find_structural_bits_portable (line 49) | fn find_structural_bits_portable() {
  function find_structural_bits_avx (line 55) | fn find_structural_bits_avx() {
  function find_structural_bits_sse (line 63) | fn find_structural_bits_sse() {
  function find_structural_bits_aarch64 (line 71) | fn find_structural_bits_aarch64() {
  function find_structural_bits_simd128 (line 77) | fn find_structural_bits_simd128() {

FILE: src/tests/serde.rs
  type TestPayload (line 33) | struct TestPayload {
  type TestEnvelope (line 38) | struct TestEnvelope {
  function test_deser_to_value (line 45) | fn test_deser_to_value() {
  function test_deser_restart (line 75) | fn test_deser_restart() {
  function empty (line 102) | fn empty() {
  function bool_true (line 112) | fn bool_true() {
  function bool_false (line 125) | fn bool_false() {
  function union (line 138) | fn union() {
  function int (line 150) | fn int() {
  function zero (line 162) | fn zero() {
  function one (line 174) | fn one() {
  function minus_one (line 186) | fn minus_one() {
  function float (line 198) | fn float() {
  function string (line 210) | fn string() {
  function lonely_quote (line 222) | fn lonely_quote() {
  function lonely_quote1 (line 232) | fn lonely_quote1() {
  function lonely_quote2 (line 241) | fn lonely_quote2() {
  function lonely_quote3 (line 251) | fn lonely_quote3() {
  function empty_string (line 261) | fn empty_string() {
  function empty_array (line 273) | fn empty_array() {
  function malformed_array (line 285) | fn malformed_array() {
  function double_array (line 303) | fn double_array() {
  function null_null_array (line 315) | fn null_null_array() {
  function one_element_array (line 334) | fn one_element_array() {
  function two_element_array (line 346) | fn two_element_array() {
  function list (line 364) | fn list() {
  function nested_list1 (line 383) | fn nested_list1() {
  function nested_list2 (line 404) | fn nested_list2() {
  function utf8 (line 413) | fn utf8() {
  function utf8_invalid_surrogates (line 423) | fn utf8_invalid_surrogates() {
  function unicode (line 432) | fn unicode() {
  function odd_array (line 441) | fn odd_array() {
  function min_i64 (line 459) | fn min_i64() {
  function map2 (line 478) | fn map2() {
  function null (line 487) | fn null() {
  function null_null (line 498) | fn null_null() {
  function nested_null (line 516) | fn nested_null() {
  function nestednested_null (line 535) | fn nestednested_null() {
  function odd_array2 (line 553) | fn odd_array2() {
  function odd_array3 (line 562) | fn odd_array3() {
  function odd_array4 (line 571) | fn odd_array4() {
  function float1 (line 580) | fn float1() {
  function float2 (line 590) | fn float2() {
  function float3 (line 600) | fn float3() {
  function map0 (line 609) | fn map0() {
  function map1 (line 623) | fn map1() {
  function tpl1 (line 638) | fn tpl1() {
  function tpl2 (line 647) | fn tpl2() {
  function tpl3 (line 656) | fn tpl3() {
  function tpl4 (line 666) | fn tpl4() {
  function tpl5 (line 674) | fn tpl5() {
  function tpl6 (line 685) | fn tpl6() {
  function tpl7 (line 696) | fn tpl7() {
  type Obj (line 707) | struct Obj {
  type Obj1 (line 713) | struct Obj1 {
  function obj1 (line 718) | fn obj1() {
  function obj2 (line 727) | fn obj2() {
  function obj3 (line 737) | fn obj3() {
  function obj4 (line 749) | fn obj4() {
  function vecvec (line 758) | fn vecvec() {
  function invalid_float_array (line 769) | fn invalid_float_array() {
  function crazy_string (line 776) | fn crazy_string() {
  function event (line 787) | fn event() {
  function arb_json (line 883) | fn arb_json() -> BoxedStrategy<String> {
  function int_map_key (line 910) | fn int_map_key() -> Result<(), crate::Error> {
  function enum_test (line 927) | fn enum_test() -> Result<(), crate::Error> {
  function invalid_float (line 951) | fn invalid_float() {
  function zero_element_touple (line 957) | fn zero_element_touple() {
  function arb_junk (line 1020) | fn arb_junk() -> BoxedStrategy<Vec<u8>> {

FILE: src/value.rs
  type ObjectHasher (line 79) | pub type ObjectHasher = crate::known_key::NotSoRandomState;
  type ObjectHasher (line 82) | pub type ObjectHasher = halfbrown::DefaultHashBuilder;
  function deserialize (line 93) | pub fn deserialize<'de, Value, Key>(s: &'de mut [u8]) -> Result<Value>
  function deserialize_with_buffers (line 115) | pub fn deserialize_with_buffers<'de, Value, Key>(
  type ValueDeserializer (line 129) | struct ValueDeserializer<'de, Value, Key>
  function from_deserializer (line 147) | pub fn from_deserializer(de: Deserializer<'de>) -> Self {
  function parse (line 155) | pub fn parse(&mut self) -> Value {
  function parse_array (line 165) | fn parse_array(&mut self, len: usize) -> Value {
  function parse_map (line 181) | fn parse_map(&mut self, len: usize) -> Value {

FILE: src/value/borrowed.rs
  type Object (line 36) | pub type Object<'value> = HashMap<Cow<'value, str>, Value<'value>, Objec...
  type Array (line 38) | pub type Array<'value> = Vec<Value<'value>>;
  function to_value (line 49) | pub fn to_value(s: &mut [u8]) -> Result<Value<'_>> {
  function to_value_with_buffers (line 67) | pub fn to_value_with_buffers<'value>(
  type Value (line 81) | pub enum Value<'value> {
  function as_static (line 93) | fn as_static(&self) -> Option<StaticNode> {
  function into_static (line 105) | pub fn into_static(self) -> Value<'static> {
  function clone_static (line 135) | pub fn clone_static(&self) -> Value<'static> {
  function null (line 164) | fn null() -> Self {
  function array_with_capacity (line 168) | fn array_with_capacity(capacity: usize) -> Self {
  function object_with_capacity (line 172) | fn object_with_capacity(capacity: usize) -> Self {
  type Array (line 181) | type Array = Array<'value>;
  method as_array_mut (line 183) | fn as_array_mut(&mut self) -> Option<&mut Vec<Value<'value>>> {
  type Object (line 191) | type Object = Object<'value>;
  method as_object_mut (line 211) | fn as_object_mut(&mut self) -> Option<&mut Object<'value>> {
  method value_type (line 221) | fn value_type(&self) -> ValueType {
  method as_null (line 232) | fn as_null(&self) -> Option<()> {
  method as_bool (line 237) | fn as_bool(&self) -> Option<bool> {
  method as_i64 (line 242) | fn as_i64(&self) -> Option<i64> {
  method as_i128 (line 247) | fn as_i128(&self) -> Option<i128> {
  method as_u64 (line 252) | fn as_u64(&self) -> Option<u64> {
  method as_u128 (line 257) | fn as_u128(&self) -> Option<u128> {
  method as_f64 (line 262) | fn as_f64(&self) -> Option<f64> {
  method cast_f64 (line 267) | fn cast_f64(&self) -> Option<f64> {
  method as_str (line 272) | fn as_str(&self) -> Option<&str> {
  type Array (line 281) | type Array = Array<'value>;
  method as_array (line 284) | fn as_array(&self) -> Option<&Vec<Value<'value>>> {
  type Object (line 293) | type Object = Object<'value>;
  method as_object (line 296) | fn as_object(&self) -> Option<&Object<'value>> {
  type String (line 305) | type String = Cow<'value, str>;
  method into_string (line 307) | fn into_string(self) -> Option<<Self as ValueIntoString>::String> {
  type Array (line 316) | type Array = Array<'value>;
  method into_array (line 318) | fn into_array(self) -> Option<<Self as ValueIntoArray>::Array> {
  type Object (line 327) | type Object = Object<'value>;
  method into_object (line 329) | fn into_object(self) -> Option<<Self as ValueIntoObject>::Object> {
  function fmt (line 339) | fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
  type Output (line 350) | type Output = Value<'value>;
  function index (line 352) | fn index(&self, index: &str) -> &Self::Output {
  type Output (line 358) | type Output = Value<'value>;
  function index (line 360) | fn index(&self, index: usize) -> &Self::Output {
  function index_mut (line 367) | fn index_mut(&mut self, index: &str) -> &mut Self::Output {
  function index_mut (line 374) | fn index_mut(&mut self, index: usize) -> &mut Self::Output {
  method default (line 381) | fn default() -> Self {
  type BorrowDeserializer (line 386) | pub(super) struct BorrowDeserializer<'de>(Deserializer<'de>);
  function from_deserializer (line 389) | pub fn from_deserializer(de: Deserializer<'de>) -> Self {
  function parse (line 394) | pub fn parse(&mut self) -> Value<'de> {
  function parse_array (line 404) | fn parse_array(&mut self, len: usize) -> Value<'de> {
  function parse_map (line 420) | fn parse_map(&mut self, len: usize) -> Value<'de> {
  type BorrowSliceDeserializer (line 440) | pub(super) struct BorrowSliceDeserializer<'tape, 'de> {
  function from_tape (line 445) | pub fn from_tape(de: &'tape [Node<'de>]) -> Self {
  function next_ (line 449) | pub unsafe fn next_(&mut self) -> Node<'de> {
  function parse (line 456) | pub fn parse(&mut self) -> Value<'de> {
  function parse_array (line 466) | fn parse_array(&mut self, len: usize) -> Value<'de> {
  function parse_map (line 482) | fn parse_map(&mut self, len: usize) -> Value<'de> {
  function object_access (line 510) | fn object_access() {
  function array_access (line 523) | fn array_access() {
  function conversions_i128 (line 540) | fn conversions_i128() {
  function conversions_i64 (line 572) | fn conversions_i64() {
  function conversions_i32 (line 604) | fn conversions_i32() {
  function conversions_i16 (line 636) | fn conversions_i16() {
  function conversions_i8 (line 669) | fn conversions_i8() {
  function conversions_usize (line 701) | fn conversions_usize() {
  function conversions_u128 (line 723) | fn conversions_u128() {
  function conversions_u64 (line 741) | fn conversions_u64() {
  function conversions_u32 (line 759) | fn conversions_u32() {
  function conversions_u16 (line 777) | fn conversions_u16() {
  function conversions_u8 (line 795) | fn conversions_u8() {
  function conversions_f64 (line 813) | fn conversions_f64() {
  function conversions_f32 (line 831) | fn conversions_f32() {
  function conversions_array (line 847) | fn conversions_array() {
  function conversions_bool (line 856) | fn conversions_bool() {
  function conversions_float (line 865) | fn conversions_float() {
  function conversions_int (line 874) | fn conversions_int() {
  function conversions_uint (line 891) | fn conversions_uint() {
  function conversions_null (line 909) | fn conversions_null() {
  function conversions_object (line 918) | fn conversions_object() {
  function conversions_str (line 927) | fn conversions_str() {
  function default (line 936) | fn default() {
  function arb_value (line 944) | fn arb_value() -> BoxedStrategy<Value<'static>> {
  function test_union_cmp (line 1077) | fn test_union_cmp() {
  function test_bool_cmp (line 1083) | fn test_bool_cmp() {
  function test_slice_cmp (line 1090) | fn test_slice_cmp() {
  function test_hashmap_cmp (line 1096) | fn test_hashmap_cmp() {
  function test_option_from (line 1109) | fn test_option_from() {

FILE: src/value/borrowed/cmp.rs
  method eq (line 8) | fn eq(&self, other: &Self) -> bool {
  function eq (line 24) | fn eq(&self, other: &&T) -> bool {
  function eq (line 31) | fn eq(&self, other: &OwnedValue) -> bool {
  function eq (line 39) | fn eq(&self, _other: &()) -> bool {
  function eq (line 46) | fn eq(&self, other: &bool) -> bool {
  function eq (line 53) | fn eq(&self, other: &str) -> bool {
  function eq (line 60) | fn eq(&self, other: &&str) -> bool {
  function eq (line 67) | fn eq(&self, other: &String) -> bool {
  function eq (line 74) | fn eq(&self, other: &i8) -> bool {
  function eq (line 81) | fn eq(&self, other: &i16) -> bool {
  function eq (line 88) | fn eq(&self, other: &i32) -> bool {
  function eq (line 95) | fn eq(&self, other: &i64) -> bool {
  function eq (line 102) | fn eq(&self, other: &i128) -> bool {
  function eq (line 109) | fn eq(&self, other: &u8) -> bool {
  function eq (line 116) | fn eq(&self, other: &u16) -> bool {
  function eq (line 123) | fn eq(&self, other: &u32) -> bool {
  function eq (line 130) | fn eq(&self, other: &u64) -> bool {
  function eq (line 137) | fn eq(&self, other: &usize) -> bool {
  function eq (line 144) | fn eq(&self, other: &u128) -> bool {
  function eq (line 151) | fn eq(&self, other: &f32) -> bool {
  function eq (line 158) | fn eq(&self, other: &f64) -> bool {
  function eq (line 168) | fn eq(&self, other: &&[T]) -> bool {
  function eq (line 180) | fn eq(&self, other: &std::collections::HashMap<K, T, S>) -> bool {

FILE: src/value/borrowed/from.rs
  function from (line 8) | fn from(b: OwnedValue) -> Self {
  function from (line 20) | fn from(s: StaticNode) -> Self {
  function from (line 30) | fn from(s: Option<T>) -> Self {
  function from (line 37) | fn from(s: &'value str) -> Self {
  function from (line 45) | fn from(c: std::borrow::Cow<'value, str>) -> Self {
  function from (line 53) | fn from(c: std::borrow::Cow<'value, str>) -> Self {
  function from (line 61) | fn from(c: beef::lean::Cow<'value, str>) -> Self {
  function from (line 68) | fn from(s: String) -> Self {
  function from (line 76) | fn from(b: bool) -> Self {
  function from (line 82) | fn from(_b: ()) -> Self {
  function from (line 90) | fn from(i: i8) -> Self {
  function from (line 97) | fn from(i: i16) -> Self {
  function from (line 104) | fn from(i: i32) -> Self {
  function from (line 111) | fn from(i: i64) -> Self {
  function from (line 119) | fn from(i: i128) -> Self {
  function from (line 127) | fn from(i: u8) -> Self {
  function from (line 134) | fn from(i: u16) -> Self {
  function from (line 141) | fn from(i: u32) -> Self {
  function from (line 148) | fn from(i: u64) -> Self {
  function from (line 156) | fn from(i: u128) -> Self {
  function from (line 163) | fn from(i: usize) -> Self {
  function from (line 171) | fn from(f: f32) -> Self {
  function from (line 178) | fn from(f: f64) -> Self {
  function from (line 188) | fn from(v: Vec<S>) -> Self {
  function from_iter (line 195) | fn from_iter<I: IntoIterator<Item = V>>(iter: I) -> Self {
  function from_iter (line 204) | fn from_iter<I: IntoIterator<Item = (K, V)>>(iter: I) -> Self {
  function from (line 215) | fn from(v: Object<'value>) -> Self {

FILE: src/value/borrowed/serialize.rs
  method encode (line 19) | fn encode(&self) -> String {
  method encode_pp (line 26) | fn encode_pp(&self) -> String {
  method write (line 33) | fn write<'writer, W>(&self, w: &mut W) -> io::Result<()>
  method write_pp (line 42) | fn write_pp<'writer, W>(&self, w: &mut W) -> io::Result<()>
  type Generator (line 51) | trait Generator: BaseGenerator {
    method write_object (line 55) | fn write_object(&mut self, object: &Object) -> io::Result<()> {
    method write_json (line 87) | fn write_json(&mut self, json: &Value) -> io::Result<()> {
    type T (line 209) | type T = Vec<u8>;
    type T (line 223) | type T = W;
  type FastGenerator (line 133) | trait FastGenerator: BaseGenerator {
    method write_object (line 137) | fn write_object(&mut self, object: &Object) -> io::Result<()> {
    method write_json (line 164) | fn write_json(&mut self, json: &Value) -> io::Result<()> {
    type T (line 205) | type T = Vec<u8>;
    type T (line 216) | type T = W;
  function null (line 232) | fn null() {
  function bool_true (line 236) | fn bool_true() {
  function bool_false (line 240) | fn bool_false() {
  function obj (line 245) | fn obj() {
  function assert_str (line 251) | fn assert_str(from: &str, to: &str) {
  function string (line 255) | fn string() {

FILE: src/value/lazy.rs
  type Value (line 44) | pub enum Value<'borrow, 'tape, 'input> {
  method default (line 53) | fn default() -> Self {
  function into_value (line 61) | pub fn into_value(self) -> borrowed::Value<'input> {
  function into_owned (line 71) | pub fn into_owned<'snot>(self) -> Value<'snot, 'tape, 'input> {
  function is_tape (line 80) | pub fn is_tape(&self) -> bool {
  function is_value (line 89) | pub fn is_value(&self) -> bool {
  function from_tape (line 94) | pub fn from_tape(tape: tape::Value<'tape, 'input>) -> Self {
  function into_tape (line 97) | unsafe fn into_tape(self) -> tape::Value<'tape, 'input> {
  function upgrade (line 104) | fn upgrade(&mut self) {
  function as_mut (line 117) | fn as_mut(&mut self) -> &mut borrowed::Value<'input> {
  function fmt (line 132) | fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
  function object_index (line 184) | fn object_index() {
  function mut_object_index (line 191) | fn mut_object_index() {
  function array_index (line 199) | fn array_index() {
  function mut_array_index (line 206) | fn mut_array_index() {
  function conversion_str (line 212) | fn conversion_str() {
  function conversions_i128 (line 218) | fn conversions_i128() {
  function conversions_i64 (line 250) | fn conversions_i64() {
  function conversions_i32 (line 282) | fn conversions_i32() {
  function conversions_i16 (line 314) | fn conversions_i16() {
  function conversions_i8 (line 347) | fn conversions_i8() {
  function conversions_usize (line 379) | fn conversions_usize() {
  function conversions_u128 (line 401) | fn conversions_u128() {
  function conversions_u64 (line 419) | fn conversions_u64() {
  function conversions_u32 (line 437) | fn conversions_u32() {
  function conversions_u16 (line 455) | fn conversions_u16() {
  function conversions_u8 (line 473) | fn conversions_u8() {
  function conversions_f64 (line 491) | fn conversions_f64() {
  function conversions_f32 (line 509) | fn conversions_f32() {
  function conversions_bool (line 525) | fn conversions_bool() {
  function conversions_float (line 534) | fn conversions_float() {
  function conversions_int (line 543) | fn conversions_int() {
  function conversions_uint (line 560) | fn conversions_uint() {
  function conversions_null (line 577) | fn conversions_null() {
  function default (line 586) | fn default() {
  function mixed_int_cmp (line 591) | fn mixed_int_cmp() {
  function mixed_int_cmp_128 (line 598) | fn mixed_int_cmp_128() {
  function test_union_cmp (line 616) | fn test_union_cmp() {
  function test_bool_cmp (line 622) | fn test_bool_cmp() {

FILE: src/value/lazy/array.rs
  type Array (line 8) | pub enum Array<'borrow, 'tape, 'input> {
  type Iter (line 16) | pub enum Iter<'borrow, 'tape, 'input> {
  type Item (line 24) | type Item = Value<'borrow, 'tape, 'input>;
  method next (line 26) | fn next(&mut self) -> Option<Self::Item> {
  function get (line 40) | pub fn get<'a>(&'a self, idx: usize) -> Option<Value<'a, 'tape, 'input>> {
  function iter (line 49) | pub fn iter<'i>(&'i self) -> Iter<'i, 'tape, 'input> {
  function len (line 58) | pub fn len(&self) -> usize {
  function is_empty (line 66) | pub fn is_empty(&self) -> bool {
  function get_ints (line 77) | fn get_ints() -> crate::Result<()> {
  function get_nested (line 91) | fn get_nested() -> crate::Result<()> {
  function iter (line 107) | fn iter() -> crate::Result<()> {
  function iter_container (line 122) | fn iter_container() -> crate::Result<()> {

FILE: src/value/lazy/cmp.rs
  function eq (line 8) | fn eq(&self, _other: &()) -> bool {
  function eq (line 15) | fn eq(&self, other: &bool) -> bool {
  function eq (line 22) | fn eq(&self, other: &str) -> bool {
  function eq (line 29) | fn eq(&self, other: &&str) -> bool {
  function eq (line 36) | fn eq(&self, other: &String) -> bool {
  function eq (line 43) | fn eq(&self, other: &i8) -> bool {
  function eq (line 50) | fn eq(&self, other: &i16) -> bool {
  function eq (line 57) | fn eq(&self, other: &i32) -> bool {
  function eq (line 64) | fn eq(&self, other: &i64) -> bool {
  function eq (line 71) | fn eq(&self, other: &i128) -> bool {
  function eq (line 78) | fn eq(&self, other: &u8) -> bool {
  function eq (line 85) | fn eq(&self, other: &u16) -> bool {
  function eq (line 92) | fn eq(&self, other: &u32) -> bool {
  function eq (line 99) | fn eq(&self, other: &u64) -> bool {
  function eq (line 106) | fn eq(&self, other: &usize) -> bool {
  function eq (line 113) | fn eq(&self, other: &u128) -> bool {
  function eq (line 120) | fn eq(&self, other: &f32) -> bool {
  function eq (line 127) | fn eq(&self, other: &f64) -> bool {
  function eq (line 139) | fn eq(&self, other: &std::collections::HashMap<K, T, S>) -> bool {

FILE: src/value/lazy/from.rs
  function from (line 8) | fn from(v: borrowed::Value<'value>) -> Self {
  function from (line 15) | fn from(v: StaticNode) -> Self {
  function from (line 25) | fn from(v: Option<T>) -> Self {
  function from (line 32) | fn from(v: &'value str) -> Self {
  function from (line 40) | fn from(v: std::borrow::Cow<'value, str>) -> Self {
  function from (line 48) | fn from(v: std::borrow::Cow<'value, str>) -> Self {
  function from (line 56) | fn from(v: beef::lean::Cow<'value, str>) -> Self {
  function from (line 63) | fn from(v: String) -> Self {
  function from (line 71) | fn from(v: bool) -> Self {
  function from (line 77) | fn from(v: ()) -> Self {
  function from (line 85) | fn from(v: i8) -> Self {
  function from (line 92) | fn from(v: i16) -> Self {
  function from (line 99) | fn from(v: i32) -> Self {
  function from (line 106) | fn from(v: i64) -> Self {
  function from (line 114) | fn from(v: i128) -> Self {
  function from (line 122) | fn from(v: u8) -> Self {
  function from (line 129) | fn from(v: u16) -> Self {
  function from (line 136) | fn from(v: u32) -> Self {
  function from (line 143) | fn from(v: u64) -> Self {
  function from (line 151) | fn from(v: u128) -> Self {
  function from (line 158) | fn from(v: usize) -> Self {
  function from (line 166) | fn from(v: f32) -> Self {
  function from (line 173) | fn from(v: f64) -> Self {
  function from (line 183) | fn from(v: Vec<S>) -> Self {
  function from_iter (line 190) | fn from_iter<I: IntoIterator<Item = V>>(v: I) -> Self {
  function from_iter (line 199) | fn from_iter<I: IntoIterator<Item = (K, V)>>(v: I) -> Self {
  function from (line 206) | fn from(v: crate::borrowed::Object<'value>) -> Self {

FILE: src/value/lazy/object.rs
  type Object (line 10) | pub enum Object<'borrow, 'tape, 'input> {
  type Iter (line 17) | pub enum Iter<'borrow, 'tape, 'input> {
  type Keys (line 25) | pub enum Keys<'borrow, 'tape, 'input> {
  type Values (line 32) | pub enum Values<'borrow, 'tape, 'input> {
  function get (line 45) | pub fn get<'a, Q>(&'a self, k: &Q) -> Option<Value<'a, 'tape, 'input>>
  function iter (line 60) | pub fn iter<'i>(&'i self) -> Iter<'i, 'tape, 'input> {
  function keys (line 69) | pub fn keys<'i>(&'i self) -> Keys<'i, 'tape, 'input> {
  function values (line 78) | pub fn values<'i>(&'i self) -> Values<'i, 'tape, 'input> {
  function len (line 87) | pub fn len(&self) -> usize {
  function is_empty (line 96) | pub fn is_empty(&self) -> bool {
  type Item (line 110) | type Item = (&'borrow str, Value<'borrow, 'tape, 'input>);
  method next (line 112) | fn next(&mut self) -> Option<Self::Item> {
  type Item (line 123) | type Item = &'borrow str;
  method next (line 124) | fn next(&mut self) -> Option<Self::Item> {
  type Item (line 133) | type Item = Value<'borrow, 'tape, 'input>;
  method next (line 134) | fn next(&mut self) -> Option<Self::Item> {
  function get_ints (line 149) | fn get_ints() -> crate::Result<()> {
  function get_container (line 163) | fn get_container() -> crate::Result<()> {
  function iter_ints (line 182) | fn iter_ints() -> crate::Result<()> {
  function keys_ints (line 201) | fn keys_ints() -> crate::Result<()> {
  function values_ints (line 216) | fn values_ints() -> crate::Result<()> {
  function iter_container (line 231) | fn iter_container() -> crate::Result<()> {
  function keys_container (line 254) | fn keys_container() -> crate::Result<()> {
  function values_container (line 270) | fn values_container() -> crate::Result<()> {

FILE: src/value/lazy/trait_impls.rs
  function null (line 27) | fn null() -> Self {
  function array_with_capacity (line 31) | fn array_with_capacity(capacity: usize) -> Self {
  function object_with_capacity (line 35) | fn object_with_capacity(capacity: usize) -> Self {
  function is_array (line 47) | pub fn is_array(&self) -> bool {
  function is_object (line 53) | pub fn is_object(&self) -> bool {
  method as_null (line 60) | fn as_null(&self) -> Option<()> {
  method as_bool (line 68) | fn as_bool(&self) -> Option<bool> {
  method as_i64 (line 76) | fn as_i64(&self) -> Option<i64> {
  method as_i128 (line 84) | fn as_i128(&self) -> Option<i128> {
  method as_u64 (line 92) | fn as_u64(&self) -> Option<u64> {
  method as_u128 (line 100) | fn as_u128(&self) -> Option<u128> {
  method as_f64 (line 108) | fn as_f64(&self) -> Option<f64> {
  method cast_f64 (line 116) | fn cast_f64(&self) -> Option<f64> {
  method as_str (line 124) | fn as_str(&self) -> Option<&str> {
  type String (line 133) | type String = Cow<'value, str>;
  method into_string (line 135) | fn into_string(self) -> Option<<Self as ValueIntoString>::String> {
  method value_type (line 185) | fn value_type(&self) -> ValueType {
  function try_get (line 202) | pub fn try_get<Q>(&self, k: &Q) -> Result<Option<Value<'_, 'tape, 'input...
  function try_get_idx (line 224) | pub fn try_get_idx(&self, i: usize) -> Result<Option<Value<'_, 'tape, 'i...
  function as_array (line 242) | pub fn as_array(&self) -> Option<Array<'_, 'tape, 'input>> {
  function as_object (line 251) | pub fn as_object(&self) -> Option<Object<'_, 'tape, 'input>> {
  type Array (line 260) | type Array = Vec<borrowed::Value<'input>>;
  method as_array_mut (line 262) | fn as_array_mut(&mut self) -> Option<&mut Vec<borrowed::Value<'input>>> {
  type Object (line 267) | type Object = super::borrowed::Object<'input>;
  method as_object_mut (line 269) | fn as_object_mut(&mut self) -> Option<&mut super::borrowed::Object<'inpu...
  function try_as_array (line 279) | pub fn try_as_array(&self) -> Result<Array<'_, 'tape, 'input>, TryTypeEr...
  function try_as_object (line 289) | pub fn try_as_object(&self) -> Result<Object<'_, 'tape, 'input>, TryType...
  function get (line 302) | pub fn get<'k, Q>(&self, k: &'k Q) -> Option<Value<'_, 'tape, 'input>>
  function contains_key (line 321) | pub fn contains_key<Q>(&self, k: &Q) -> bool
  function get_idx (line 341) | pub fn get_idx(&self, i: usize) -> Option<Value<'_, 'tape, 'input>> {
  function get_bool (line 359) | pub fn get_bool<Q>(&self, k: &Q) -> Option<bool>
  function get_i128 (line 370) | pub fn get_i128<Q>(&self, k: &Q) -> Option<i128>
  function get_i64 (line 381) | pub fn get_i64<Q>(&self, k: &Q) -> Option<i64>
  function get_i32 (line 392) | pub fn get_i32<Q>(&self, k: &Q) -> Option<i32>
  function get_i16 (line 403) | pub fn get_i16<Q>(&self, k: &Q) -> Option<i16>
  function get_i8 (line 414) | pub fn get_i8<Q>(&self, k: &Q) -> Option<i8>
  function get_u128 (line 425) | pub fn get_u128<Q>(&self, k: &Q) -> Option<u128>
  function get_u64 (line 436) | pub fn get_u64<Q>(&self, k: &Q) -> Option<u64>
  function get_usize (line 447) | pub fn get_usize<Q>(&self, k: &Q) -> Option<usize>
  function get_u32 (line 458) | pub fn get_u32<Q>(&self, k: &Q) -> Option<u32>
  function get_u16 (line 469) | pub fn get_u16<Q>(&self, k: &Q) -> Option<u16>
  function get_u8 (line 480) | pub fn get_u8<Q>(&self, k: &Q) -> Option<u8>
  function get_f64 (line 491) | pub fn get_f64<Q>(&self, k: &Q) -> Option<f64>
  function get_f32 (line 502) | pub fn get_f32<Q>(&self, k: &Q) -> Option<f32>
  function get_str (line 512) | pub fn get_str<Q>(&self, k: &Q) -> Option<&str>
  function get_array (line 529) | pub fn get_array<Q>(&self, k: &Q) -> Option<Array<'_, 'tape, 'input>>
  function get_object (line 543) | pub fn get_object<Q>(&self, k: &Q) -> Option<Object<'_, 'tape, 'input>>
  function try_get_array (line 561) | pub fn try_get_array<Q>(&self, k: &Q) -> Result<Option<Array<'_, 'tape, ...
  function try_get_object (line 578) | pub fn try_get_object<Q>(
  function try_get_bool (line 600) | pub fn try_get_bool<Q>(&self, k: &Q) -> Result<Option<bool>, TryTypeError>
  function try_get_i128 (line 614) | pub fn try_get_i128<Q>(&self, k: &Q) -> Result<Option<i128>, TryTypeError>
  function try_get_i64 (line 628) | pub fn try_get_i64<Q>(&self, k: &Q) -> Result<Option<i64>, TryTypeError>
  function try_get_i32 (line 642) | pub fn try_get_i32<Q>(&self, k: &Q) -> Result<Option<i32>, TryTypeError>
  function try_get_i16 (line 656) | pub fn try_get_i16<Q>(&self, k: &Q) -> Result<Option<i16>, TryTypeError>
  function try_get_i8 (line 670) | pub fn try_get_i8<Q>(&self, k: &Q) -> Result<Option<i8>, TryTypeError>
  function try_get_u128 (line 684) | pub fn try_get_u128<Q>(&self, k: &Q) -> Result<Option<u128>, TryTypeError>
  function try_get_u64 (line 698) | pub fn try_get_u64<Q>(&self, k: &Q) -> Result<Option<u64>, TryTypeError>
  function try_get_usize (line 712) | pub fn try_get_usize<Q>(&self, k: &Q) -> Result<Option<usize>, TryTypeEr...
  function try_get_u32 (line 726) | pub fn try_get_u32<Q>(&self, k: &Q) -> Result<Option<u32>, TryTypeError>
  function try_get_u16 (line 740) | pub fn try_get_u16<Q>(&self, k: &Q) -> Result<Option<u16>, TryTypeError>
  function try_get_u8 (line 754) | pub fn try_get_u8<Q>(&self, k: &Q) -> Result<Option<u8>, TryTypeError>
  function try_get_f64 (line 768) | pub fn try_get_f64<Q>(&self, k: &Q) -> Result<Option<f64>, TryTypeError>
  function try_get_f32 (line 782) | pub fn try_get_f32<Q>(&self, k: &Q) -> Result<Option<f32>, TryTypeError>
  function try_get_str (line 796) | pub fn try_get_str<Q>(&self, k: &Q) -> Result<Option<&'_ str>, TryTypeEr...
  method encode (line 811) | fn encode(&self) -> String {
  method encode_pp (line 819) | fn encode_pp(&self) -> String {
  method write (line 827) | fn write<'writer, W>(&self, w: &mut W) -> io::Result<()>
  method write_pp (line 838) | fn write_pp<'writer, W>(&self, w: &mut W) -> io::Result<()>

FILE: src/value/owned.rs
  type Object (line 34) | pub type Object = HashMap<String, Value, ObjectHasher>;
  function to_value (line 46) | pub fn to_value(s: &mut [u8]) -> Result<Value> {
  function to_value_with_buffers (line 65) | pub fn to_value_with_buffers(s: &mut [u8], buffers: &mut Buffers) -> Res...
  type Value (line 78) | pub enum Value {
    method as_static (line 90) | fn as_static(&self) -> Option<StaticNode> {
    method null (line 100) | fn null() -> Self {
    method array_with_capacity (line 104) | fn array_with_capacity(capacity: usize) -> Self {
    method object_with_capacity (line 108) | fn object_with_capacity(capacity: usize) -> Self {
    method fmt (line 251) | fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
    type Output (line 262) | type Output = Self;
    method index (line 264) | fn index(&self, index: &str) -> &Self::Output {
    type Output (line 270) | type Output = Self;
    method index (line 272) | fn index(&self, index: usize) -> &Self::Output {
    method index_mut (line 279) | fn index_mut(&mut self, index: &str) -> &mut Self::Output {
    method index_mut (line 286) | fn index_mut(&mut self, index: usize) -> &mut Self::Output {
  type Array (line 117) | type Array = Vec<Self>;
  method as_array_mut (line 119) | fn as_array_mut(&mut self) -> Option<&mut Vec<Self>> {
  type Object (line 127) | type Object = Object;
  method as_object_mut (line 129) | fn as_object_mut(&mut self) -> Option<&mut Object> {
  method value_type (line 139) | fn value_type(&self) -> ValueType {
  method as_null (line 150) | fn as_null(&self) -> Option<()> {
  method as_bool (line 154) | fn as_bool(&self) -> Option<bool> {
  method as_i64 (line 159) | fn as_i64(&self) -> Option<i64> {
  method as_i128 (line 164) | fn as_i128(&self) -> Option<i128> {
  method as_u64 (line 169) | fn as_u64(&self) -> Option<u64> {
  method as_u128 (line 174) | fn as_u128(&self) -> Option<u128> {
  method as_f64 (line 179) | fn as_f64(&self) -> Option<f64> {
  method cast_f64 (line 184) | fn cast_f64(&self) -> Option<f64> {
  method as_str (line 189) | fn as_str(&self) -> Option<&str> {
  type Array (line 197) | type Array = Vec<Self>;
  method as_array (line 199) | fn as_array(&self) -> Option<&Vec<Self>> {
  type Object (line 207) | type Object = Object;
  method as_object (line 210) | fn as_object(&self) -> Option<&Object> {
  type String (line 219) | type String = String;
  method into_string (line 221) | fn into_string(self) -> Option<<Value as ValueIntoString>::String> {
  type Array (line 229) | type Array = Vec<Self>;
  method into_array (line 231) | fn into_array(self) -> Option<<Value as ValueIntoArray>::Array> {
  type Object (line 239) | type Object = Object;
  method into_object (line 241) | fn into_object(self) -> Option<<Value as ValueIntoObject>::Object> {
  method default (line 293) | fn default() -> Self {
  type OwnedDeserializer (line 298) | struct OwnedDeserializer<'de> {
  function from_deserializer (line 303) | pub fn from_deserializer(de: Deserializer<'de>) -> Self {
  function parse (line 307) | pub fn parse(&mut self) -> Value {
  function parse_array (line 317) | fn parse_array(&mut self, len: usize) -> Value {
  function parse_map (line 333) | fn parse_map(&mut self, len: usize) -> Value {
  function object_access (line 358) | fn object_access() {
  function array_access (line 371) | fn array_access() {
  function conversions_i128 (line 388) | fn conversions_i128() {
  function conversions_i64 (line 419) | fn conversions_i64() {
  function conversions_i32 (line 451) | fn conversions_i32() {
  function conversions_i16 (line 483) | fn conversions_i16() {
  function conversions_i8 (line 516) | fn conversions_i8() {
  function conversions_usize (line 548) | fn conversions_usize() {
  function conversions_u128 (line 570) | fn conversions_u128() {
  function conversions_u64 (line 587) | fn conversions_u64() {
  function conversions_u32 (line 605) | fn conversions_u32() {
  function conversions_u16 (line 623) | fn conversions_u16() {
  function conversions_u8 (line 641) | fn conversions_u8() {
  function conversions_f64 (line 659) | fn conversions_f64() {
  function conversions_f32 (line 677) | fn conversions_f32() {
  function conversions_array (line 693) | fn conversions_array() {
  function conversions_bool (line 702) | fn conversions_bool() {
  function conversions_float (line 711) | fn conversions_float() {
  function conversions_int (line 720) | fn conversions_int() {
  function conversions_uint (line 738) | fn conversions_uint() {
  function conversions_null (line 756) | fn conversions_null() {
  function conversions_object (line 765) | fn conversions_object() {
  function conversions_str (line 774) | fn conversions_str() {
  function default (line 783) | fn default() {
  function arb_value (line 790) | fn arb_value() -> BoxedStrategy<Value> {
  function test_union_cmp (line 911) | fn test_union_cmp() {
  function test_bool_cmp (line 917) | fn test_bool_cmp() {
  function test_slice_cmp (line 924) | fn test_slice_cmp() {
  function test_hashmap_cmp (line 930) | fn test_hashmap_cmp() {
  function test_option_from (line 942) | fn test_option_from() {

FILE: src/value/owned/cmp.rs
  method eq (line 7) | fn eq(&self, other: &BorrowedValue<'_>) -> bool {
  method eq (line 27) | fn eq(&self, other: &Self) -> bool {
  method eq (line 43) | fn eq(&self, other: &&T) -> bool {
  method eq (line 50) | fn eq(&self, _other: &()) -> bool {
  method eq (line 57) | fn eq(&self, other: &bool) -> bool {
  method eq (line 64) | fn eq(&self, other: &str) -> bool {
  method eq (line 71) | fn eq(&self, other: &&str) -> bool {
  method eq (line 78) | fn eq(&self, other: &String) -> bool {
  method eq (line 85) | fn eq(&self, other: &i8) -> bool {
  method eq (line 92) | fn eq(&self, other: &i16) -> bool {
  method eq (line 99) | fn eq(&self, other: &i32) -> bool {
  method eq (line 106) | fn eq(&self, other: &i64) -> bool {
  method eq (line 113) | fn eq(&self, other: &i128) -> bool {
  method eq (line 120) | fn eq(&self, other: &u8) -> bool {
  method eq (line 127) | fn eq(&self, other: &u16) -> bool {
  method eq (line 134) | fn eq(&self, other: &u32) -> bool {
  method eq (line 141) | fn eq(&self, other: &u64) -> bool {
  method eq (line 148) | fn eq(&self, other: &usize) -> bool {
  method eq (line 155) | fn eq(&self, other: &u128) -> bool {
  method eq (line 162) | fn eq(&self, other: &f32) -> bool {
  method eq (line 169) | fn eq(&self, other: &f64) -> bool {
  method eq (line 179) | fn eq(&self, other: &&[T]) -> bool {
  method eq (line 190) | fn eq(&self, other: &std::collections::HashMap<K, T, S>) -> bool {

FILE: src/value/owned/from.rs
  method from (line 6) | fn from(b: BorrowedValue<'_>) -> Self {
  method from (line 21) | fn from(s: Option<T>) -> Self {
  method from (line 28) | fn from(s: StaticNode) -> Self {
  method from (line 36) | fn from(s: &str) -> Self {
  method from (line 43) | fn from(c: std::borrow::Cow<'value, str>) -> Self {
  method from (line 51) | fn from(c: beef::lean::Cow<'value, str>) -> Self {
  method from (line 58) | fn from(s: String) -> Self {
  method from (line 65) | fn from(s: &String) -> Self {
  method from (line 74) | fn from(b: bool) -> Self {
  method from (line 81) | fn from(_b: ()) -> Self {
  method from (line 89) | fn from(i: i8) -> Self {
  method from (line 96) | fn from(i: i16) -> Self {
  method from (line 103) | fn from(i: i32) -> Self {
  method from (line 110) | fn from(i: i64) -> Self {
  method from (line 117) | fn from(i: i128) -> Self {
  method from (line 125) | fn from(i: u8) -> Self {
  method from (line 132) | fn from(i: u16) -> Self {
  method from (line 139) | fn from(i: u32) -> Self {
  method from (line 147) | fn from(i: u64) -> Self {
  method from (line 155) | fn from(i: u128) -> Self {
  method from (line 162) | fn from(i: usize) -> Self {
  method from (line 170) | fn from(f: f32) -> Self {
  method from (line 177) | fn from(f: f64) -> Self {
  method from (line 187) | fn from(v: Vec<S>) -> Self {
  method from_iter (line 194) | fn from_iter<I: IntoIterator<Item = V>>(iter: I) -> Self {
  method from_iter (line 201) | fn from_iter<I: IntoIterator<Item = (K, V)>>(iter: I) -> Self {
  method from (line 212) | fn from(v: Object) -> Self {
  method from (line 219) | fn from(v: std::collections::HashMap<String, Self>) -> Self {

FILE: src/value/owned/serialize.rs
  method encode (line 19) | fn encode(&self) -> String {
  method encode_pp (line 26) | fn encode_pp(&self) -> String {
  method write (line 33) | fn write<'writer, W>(&self, w: &mut W) -> io::Result<()>
  method write_pp (line 42) | fn write_pp<'writer, W>(&self, w: &mut W) -> io::Result<()>
  type Generator (line 51) | trait Generator: BaseGenerator {
    method write_object (line 55) | fn write_object(&mut self, object: &Object) -> io::Result<()> {
    method write_json (line 87) | fn write_json(&mut self, json: &Value) -> io::Result<()> {
    type T (line 211) | type T = Vec<u8>;
    type T (line 225) | type T = W;
  type FastGenerator (line 135) | trait FastGenerator: BaseGenerator {
    method write_object (line 139) | fn write_object(&mut self, object: &Object) -> io::Result<()> {
    method write_json (line 166) | fn write_json(&mut self, json: &Value) -> io::Result<()> {
    type T (line 207) | type T = Vec<u8>;
    type T (line 218) | type T = W;
  function null (line 234) | fn null() {
  function bool_true (line 238) | fn bool_true() {
  function bool_false (line 242) | fn bool_false() {
  function obj (line 247) | fn obj() {
  function assert_str (line 252) | fn assert_str(from: &str, to: &str) {
  function string (line 257) | fn string() {

FILE: src/value/tape.rs
  type Tape (line 11) | pub struct Tape<'input>(pub Vec<Node<'input>>);
  function as_value (line 17) | pub fn as_value(&self) -> Value<'_, 'input> {
  function null (line 23) | pub fn null() -> Self {
  function reset (line 30) | pub fn reset<'new>(mut self) -> Tape<'new> {
  function deserialize (line 41) | pub fn deserialize<T>(self) -> crate::Result<T>
  type Value (line 59) | pub struct Value<'tape, 'input>(pub(crate) &'tape [Node<'input>])
  constant NULL_TAPE (line 64) | const NULL_TAPE: [Node<'static>; 1] = [Node::Static(StaticNode::Null)];
  constant NULL (line 66) | pub const NULL: Value<'static, 'static> = Value(&Self::NULL_TAPE);
  function null (line 69) | pub const fn null() -> Self {
  type Node (line 77) | pub enum Node<'input> {
  function as_str (line 104) | fn as_str(&self) -> Option<&'input str> {
  function value_type (line 113) | pub fn value_type(&self) -> ValueType {
  function array_count (line 123) | fn array_count(&self) -> Result<usize, TryTypeError> {
  function object_count (line 147) | fn object_count(&self) -> Result<usize, TryTypeError> {
  function object_len (line 159) | fn object_len(&self) -> Result<usize, TryTypeError> {
  function count (line 171) | fn count(&self) -> usize {
  function object_index (line 204) | fn object_index() {
  function mut_object_index (line 211) | fn mut_object_index() {
  function array_index (line 219) | fn array_index() {
  function mut_array_index (line 226) | fn mut_array_index() {
  function conversion_str (line 232) | fn conversion_str() {
  function conversions_i128 (line 238) | fn conversions_i128() {
  function conversions_i64 (line 270) | fn conversions_i64() {
  function conversions_i32 (line 302) | fn conversions_i32() {
  function conversions_i16 (line 334) | fn conversions_i16() {
  function conversions_i8 (line 367) | fn conversions_i8() {
  function conversions_usize (line 399) | fn conversions_usize() {
  function conversions_u128 (line 421) | fn conversions_u128() {
  function conversions_u64 (line 439) | fn conversions_u64() {
  function conversions_u32 (line 457) | fn conversions_u32() {
  function conversions_u16 (line 475) | fn conversions_u16() {
  function conversions_u8 (line 493) | fn conversions_u8() {
  function conversions_f64 (line 511) | fn conversions_f64() {
  function conversions_f32 (line 529) | fn conversions_f32() {
  function conversions_bool (line 545) | fn conversions_bool() {
  function conversions_float (line 554) | fn conversions_float() {
  function conversions_int (line 563) | fn conversions_int() {
  function conversions_uint (line 580) | fn conversions_uint() {
  function conversions_null (line 597) | fn conversions_null() {
  function default (line 606) | fn default() {
  function mixed_int_cmp (line 611) | fn mixed_int_cmp() {
  function mixed_int_cmp_128 (line 618) | fn mixed_int_cmp_128() {
  function test_union_cmp (line 636) | fn test_union_cmp() {
  function test_bool_cmp (line 642) | fn test_bool_cmp() {

FILE: src/value/tape/array.rs
  type Array (line 6) | pub struct Array<'tape, 'input>(pub(super) &'tape [Node<'input>]);
  type Iter (line 8) | pub struct Iter<'tape, 'input>(&'tape [Node<'input>]);
  type Item (line 11) | type Item = Value<'tape, 'input>;
  method next (line 13) | fn next(&mut self) -> Option<Self::Item> {
  function get (line 29) | pub fn get(&self, mut idx: usize) -> Option<Value<'tape, 'input>> {
  function iter (line 41) | pub fn iter<'i>(&'i self) -> Iter<'tape, 'input> {
  function len (line 49) | pub fn len(&self) -> usize {
  function is_empty (line 58) | pub fn is_empty(&self) -> bool {
  type IntoIter (line 64) | type IntoIter = Iter<'tape, 'input>;
  type Item (line 65) | type Item = Value<'tape, 'input>;
  method into_iter (line 66) | fn into_iter(self) -> Self::IntoIter {
  function get_ints (line 77) | fn get_ints() -> crate::Result<()> {
  function get_nested (line 91) | fn get_nested() -> crate::Result<()> {
  function iter (line 107) | fn iter() -> crate::Result<()> {
  function iter_container (line 122) | fn iter_container() -> crate::Result<()> {

FILE: src/value/tape/cmp.rs
  method eq (line 10) | fn eq(&self, other: &Self) -> bool {
  function eq (line 20) | fn eq(&self, other: &&T) -> bool {
  function eq (line 27) | fn eq(&self, _other: &()) -> bool {
  function eq (line 34) | fn eq(&self, other: &bool) -> bool {
  function eq (line 41) | fn eq(&self, other: &str) -> bool {
  function eq (line 48) | fn eq(&self, other: &&str) -> bool {
  function eq (line 55) | fn eq(&self, other: &String) -> bool {
  function eq (line 62) | fn eq(&self, other: &i8) -> bool {
  function eq (line 69) | fn eq(&self, other: &i16) -> bool {
  function eq (line 76) | fn eq(&self, other: &i32) -> bool {
  function eq (line 83) | fn eq(&self, other: &i64) -> bool {
  function eq (line 90) | fn eq(&self, other: &i128) -> bool {
  function eq (line 97) | fn eq(&self, other: &u8) -> bool {
  function eq (line 104) | fn eq(&self, other: &u16) -> bool {
  function eq (line 111) | fn eq(&self, other: &u32) -> bool {
  function eq (line 118) | fn eq(&self, other: &u64) -> bool {
  function eq (line 125) | fn eq(&self, other: &usize) -> bool {
  function eq (line 132) | fn eq(&self, other: &u128) -> bool {
  function eq (line 139) | fn eq(&self, other: &f32) -> bool {
  function eq (line 146) | fn eq(&self, other: &f64) -> bool {
  function eq (line 158) | fn eq(&self, other: &std::collections::HashMap<K, T, S>) -> bool {

FILE: src/value/tape/object.rs
  type Object (line 7) | pub struct Object<'tape, 'input>(pub(super) &'tape [Node<'input>]);
  type Iter (line 9) | pub struct Iter<'tape, 'input>(&'tape [Node<'input>]);
  type Keys (line 10) | pub struct Keys<'tape, 'input>(&'tape [Node<'input>]);
  type Values (line 11) | pub struct Values<'tape, 'input>(&'tape [Node<'input>]);
  function get (line 19) | pub fn get<Q>(&self, k: &Q) -> Option<Value<'tape, 'input>>
  function iter (line 44) | pub fn iter<'i>(&'i self) -> Iter<'tape, 'input> {
  function keys (line 50) | pub fn keys<'i>(&'i self) -> Keys<'tape, 'input> {
  function values (line 56) | pub fn values<'i>(&'i self) -> Values<'tape, 'input> {
  function len (line 62) | pub fn len(&self) -> usize {
  function is_empty (line 71) | pub fn is_empty(&self) -> bool {
  type IntoIter (line 77) | type IntoIter = Iter<'tape, 'input>;
  type Item (line 78) | type Item = (&'input str, Value<'tape, 'input>);
  method into_iter (line 79) | fn into_iter(self) -> Self::IntoIter {
  type Item (line 85) | type Item = (&'input str, Value<'tape, 'input>);
  method next (line 87) | fn next(&mut self) -> Option<Self::Item> {
  type Item (line 98) | type Item = &'input str;
  method next (line 99) | fn next(&mut self) -> Option<Self::Item> {
  type Item (line 110) | type Item = Value<'tape, 'input>;
  method next (line 111) | fn next(&mut self) -> Option<Self::Item> {
  function get_ints (line 127) | fn get_ints() -> crate::Result<()> {
  function get_container (line 141) | fn get_container() -> crate::Result<()> {
  function iter_ints (line 160) | fn iter_ints() -> crate::Result<()> {
  function keys_ints (line 179) | fn keys_ints() -> crate::Result<()> {
  function values_ints (line 194) | fn values_ints() -> crate::Result<()> {
  function iter_container (line 209) | fn iter_container() -> crate::Result<()> {
  function keys_container (line 232) | fn keys_container() -> crate::Result<()> {
  function values_container (line 248) | fn values_container() -> crate::Result<()> {

FILE: src/value/tape/trait_impls.rs
  function as_static (line 25) | fn as_static(&self) -> Option<StaticNode> {
  function is_array (line 37) | pub fn is_array(&self) -> bool {
  function is_object (line 43) | pub fn is_object(&self) -> bool {
  method as_null (line 53) | fn as_null(&self) -> Option<()> {
  method as_bool (line 58) | fn as_bool(&self) -> Option<bool> {
  method as_i64 (line 63) | fn as_i64(&self) -> Option<i64> {
  method as_u64 (line 68) | fn as_u64(&self) -> Option<u64> {
  method as_f64 (line 73) | fn as_f64(&self) -> Option<f64> {
  method as_str (line 78) | fn as_str(&self) -> Option<&'input str> {
  type String (line 84) | type String = &'input str;
  method into_string (line 86) | fn into_string(self) -> Option<&'input str> {
  type Array (line 96) | type Array = Array<'tape, 'input>;
  method into_array (line 97) | fn into_array(self) -> Option<Self::Array> {
  type Object (line 108) | type Object = Object<'tape, 'input>;
  method into_object (line 109) | fn into_object(self) -> Option<Self::Object> {
  method value_type (line 122) | fn value_type(&self) -> ValueType {
  function try_get (line 149) | pub fn try_get<Q>(&self, k: &Q) -> Result<Option<Value<'tape, 'input>>, ...
  function try_get_idx (line 167) | pub fn try_get_idx(&self, i: usize) -> Result<Option<Value<'tape, 'input...
  function as_array (line 179) | pub fn as_array(&self) -> Option<Array<'tape, 'input>> {
  function as_object (line 191) | pub fn as_object(&self) -> Option<Object<'tape, 'input>> {
  function try_as_array (line 207) | pub fn try_as_array(&self) -> Result<Array<'tape, 'input>, TryTypeError> {
  function try_as_object (line 217) | pub fn try_as_object(&self) -> Result<Object<'tape, 'input>, TryTypeErro...
  function get (line 229) | pub fn get<Q>(&self, k: &Q) -> Option<Value<'tape, 'input>>
  function contains_key (line 240) | pub fn contains_key(&self, k: &str) -> bool {
  function get_idx (line 251) | pub fn get_idx(&self, i: usize) -> Option<Value<'tape, 'input>> {
  type Key (line 260) | type Key = str;
  method get_bool (line 262) | fn get_bool<Q>(&self, k: &Q) -> Option<bool>
  method get_i128 (line 271) | fn get_i128<Q>(&self, k: &Q) -> Option<i128>
  method get_i64 (line 280) | fn get_i64<Q>(&self, k: &Q) -> Option<i64>
  method get_i32 (line 289) | fn get_i32<Q>(&self, k: &Q) -> Option<i32>
  method get_i16 (line 298) | fn get_i16<Q>(&self, k: &Q) -> Option<i16>
  method get_i8 (line 307) | fn get_i8<Q>(&self, k: &Q) -> Option<i8>
  method get_u128 (line 316) | fn get_u128<Q>(&self, k: &Q) -> Option<u128>
  method get_u64 (line 325) | fn get_u64<Q>(&self, k: &Q) -> Option<u64>
  method get_usize (line 334) | fn get_usize<Q>(&self, k: &Q) -> Option<usize>
  method get_u32 (line 343) | fn get_u32<Q>(&self, k: &Q) -> Option<u32>
  method get_u16 (line 352) | fn get_u16<Q>(&self, k: &Q) -> Option<u16>
  method get_u8 (line 361) | fn get_u8<Q>(&self, k: &Q) -> Option<u8>
  method get_f64 (line 370) | fn get_f64<Q>(&self, k: &Q) -> Option<f64>
  method get_f32 (line 379) | fn get_f32<Q>(&self, k: &Q) -> Option<f32>
  method get_str (line 388) | fn get_str<Q>(&self, k: &Q) -> Option<&'input str>
  function get_array (line 405) | pub fn get_array<Q>(&self, k: &Q) -> Option<Array<'tape, 'input>>
  function get_object (line 434) | pub fn get_object<Q>(&self, k: &Q) -> Option<Object<'tape, 'input>>
  function try_get_array (line 467) | pub fn try_get_array<Q>(&self, k: &Q) -> Result<Option<Array<'tape, 'inp...
  function try_get_object (line 499) | pub fn try_get_object<Q>(&self, k: &Q) -> Result<Option<Object<'tape, 'i...
  type Key (line 528) | type Key = str;
  method try_get_bool (line 529) | fn try_get_bool<Q>(&self, k: &Q) -> Result<Option<bool>, TryTypeError>
  method try_get_i128 (line 538) | fn try_get_i128<Q>(&self, k: &Q) -> Result<Option<i128>, TryTypeError>
  method try_get_i64 (line 547) | fn try_get_i64<Q>(&self, k: &Q) -> Result<Option<i64>, TryTypeError>
  method try_get_i32 (line 556) | fn try_get_i32<Q>(&self, k: &Q) -> Result<Option<i32>, TryTypeError>
  method try_get_i16 (line 565) | fn try_get_i16<Q>(&self, k: &Q) -> Result<Option<i16>, TryTypeError>
  method try_get_i8 (line 574) | fn try_get_i8<Q>(&self, k: &Q) -> Result<Option<i8>, TryTypeError>
  method try_get_u128 (line 583) | fn try_get_u128<Q>(&self, k: &Q) -> Result<Option<u128>, TryTypeError>
  method try_get_u64 (line 592) | fn try_get_u64<Q>(&self, k: &Q) -> Result<Option<u64>, TryTypeError>
  method try_get_usize (line 601) | fn try_get_usize<Q>(&self, k: &Q) -> Result<Option<usize>, TryTypeError>
  method try_get_u32 (line 610) | fn try_get_u32<Q>(&self, k: &Q) -> Result<Option<u32>, TryTypeError>
  method try_get_u16 (line 619) | fn try_get_u16<Q>(&self, k: &Q) -> Result<Option<u16>, TryTypeError>
  method try_get_u8 (line 628) | fn try_get_u8<Q>(&self, k: &Q) -> Result<Option<u8>, TryTypeError>
  method try_get_f64 (line 637) | fn try_get_f64<Q>(&self, k: &Q) -> Result<Option<f64>, TryTypeError>
  method try_get_f32 (line 646) | fn try_get_f32<Q>(&self, k: &Q) -> Result<Option<f32>, TryTypeError>
  method try_get_str (line 655) | fn try_get_str<Q>(&self, k: &Q) -> Result<Option<&str>, TryTypeError>
  method encode (line 669) | fn encode(&self) -> String {
  method encode_pp (line 676) | fn encode_pp(&self) -> String {
  method write (line 683) | fn write<'writer, W>(&self, w: &mut W) -> io::Result<()>
  method write_pp (line 692) | fn write_pp<'writer, W>(&self, w: &mut W) -> io::Result<()>
  type Generator (line 701) | trait Generator: BaseGenerator {
    method write_object (line 705) | fn write_object(&mut self, object: &Object) -> io::Result<()> {
    method write_json (line 737) | fn write_json(&mut self, json: &Value) -> io::Result<()> {
    type T (line 862) | type T = Vec<u8>;
    type T (line 876) | type T = W;
  type FastGenerator (line 785) | trait FastGenerator: BaseGenerator {
    method write_object (line 789) | fn write_object(&mut self, object: &Object) -> io::Result<()> {
    method write_json (line 816) | fn write_json(&mut self, json: &Value) -> io::Result<()> {
    type T (line 858) | type T = Vec<u8>;
    type T (line 869) | type T = W;

FILE: tests/ordered_float.rs
  function test_values_as_hashmap_keys (line 11) | fn test_values_as_hashmap_keys() {

FILE: tests/serde_128_bit.rs
  function lgostash_int_bug (line 4) | fn lgostash_int_bug() {
  function lgostash_int_bug2 (line 38) | fn lgostash_int_bug2() {

FILE: tests/serenity.rs
  function deserialize (line 9) | pub fn deserialize<'de, D: Deserializer<'de>>(deserializer: D) -> Result...
  function serialize (line 14) | pub fn serialize<S: Serializer>(id: &u64, serializer: S) -> Result<S::Ok...
  type SnowflakeVisitor (line 18) | struct SnowflakeVisitor;
    type Value (line 21) | type Value = u64;
    method expecting (line 23) | fn expecting(&self, formatter: &mut fmt::Formatter<'_>) -> fmt::Result {
    method visit_i64 (line 28) | fn visit_i64<E: Error>(self, value: i64) -> Result<Self::Value, E> {
    method visit_u64 (line 32) | fn visit_u64<E: Error>(self, value: u64) -> Result<Self::Value, E> {
    method visit_str (line 36) | fn visit_str<E: Error>(self, value: &str) -> Result<Self::Value, E> {
  type ChannelId (line 50) | pub struct ChannelId(#[serde(with = "snowflake")] pub u64);
  function simd_json_test (line 53) | fn simd_json_test() {
  function serde_test (line 62) | fn serde_test() {

FILE: tests/weird_type.rs
  type WeirdTypeVisitor (line 12) | struct WeirdTypeVisitor;
    type Value (line 15) | type Value = bool;
    method expecting (line 17) | fn expecting(&self, f: &mut Formatter<'_>) -> FmtResult {
    method visit_none (line 22) | fn visit_none<E: DeError>(self) -> Result<Self::Value, E> {
    method visit_unit (line 27) | fn visit_unit<E: DeError>(self) -> Result<Self::Value, E> {
  function serialize (line 35) | pub fn serialize<S: Serializer>(_: &bool, serializer: S) -> Result<S::Ok...
  function deserialize (line 39) | pub fn deserialize<'de, D: Deserializer<'de>>(deserializer: D) -> Result...
  function is_false (line 46) | fn is_false(value: &bool) -> bool {
  type WeirdType (line 51) | pub struct WeirdType {
  constant MISSING_EXPECTED (line 60) | const MISSING_EXPECTED: WeirdType = WeirdType { field: false };
  constant MISSING_INPUT (line 61) | const MISSING_INPUT: &str = r#"{}"#;
  constant PRESENT_EXPECTED (line 62) | const PRESENT_EXPECTED: WeirdType = WeirdType { field: true };
  constant PRESENT_INPUT (line 63) | const PRESENT_INPUT: &str = r#"{
  function test_serde_json (line 68) | fn test_serde_json() {
  function test_simd_json (line 80) | fn test_simd_json() {