{
  "isIncomplete": true,
  "items": [
    {
      "label": "new",
      "kind": 3,
      "detail": "pub const fn new() -> String",
      "documentation": {
        "kind": "markdown",
        "value": "Creates a new empty `String`.\n\nGiven that the `String` is empty, this will not allocate any initial\nbuffer. While that means that this initial operation is very\ninexpensive, it may cause excessive allocation later when you add\ndata. If you have an idea of how much data the `String` will hold,\nconsider the [`with_capacity`] method to prevent excessive\nre-allocation.\n\n[`with_capacity`]: String::with_capacity\n\n# Examples\n\n```rust\nlet s = String::new();\n```"
      },
      "preselect": true,
      "sortText": "7ffffff0",
      "filterText": "new",
      "textEdit": {
        "range": {
          "start": {
            "line": 20,
            "character": 8
          },
          "end": {
            "line": 20,
            "character": 12
          }
        },
        "newText": "new"
      }
    },
    {
      "label": "with_capacity",
      "kind": 3,
      "detail": "pub fn with_capacity(capacity: usize) -> String",
      "documentation": {
        "kind": "markdown",
        "value": "Creates a new empty `String` with at least the specified capacity.\n\n`String`s have an internal buffer to hold their data. The capacity is\nthe length of that buffer, and can be queried with the [`capacity`]\nmethod. This method creates an empty `String`, but one with an initial\nbuffer that can hold at least `capacity` bytes. This is useful when you\nmay be appending a bunch of data to the `String`, reducing the number of\nreallocations it needs to do.\n\n[`capacity`]: String::capacity\n\nIf the given capacity is `0`, no allocation will occur, and this method\nis identical to the [`new`] method.\n\n[`new`]: String::new\n\n# Examples\n\n```rust\nlet mut s = String::with_capacity(10);\n\n// The String contains no chars, even though it has capacity for more\nassert_eq!(s.len(), 0);\n\n// These are all done without reallocating...\nlet cap = s.capacity();\nfor _ in 0..10 {\n    s.push('a');\n}\n\nassert_eq!(s.capacity(), cap);\n\n// ...but this may make the string reallocate\ns.push('a');\n```"
      },
      "sortText": "7ffffff1",
      "filterText": "with_capacity",
      "textEdit": {
        "range": {
          "start": {
            "line": 20,
            "character": 8
          },
          "end": {
            "line": 20,
            "character": 12
          }
        },
        "newText": "with_capacity"
      }
    },
    {
      "label": "try_with_capacity",
      "kind": 3,
      "detail": "pub fn try_with_capacity(capacity: usize) -> Result<String, TryReserveError>",
      "documentation": {
        "kind": "markdown",
        "value": "Creates a new empty `String` with at least the specified capacity.\n\n# Errors\n\nReturns [`Err`] if the capacity exceeds `isize::MAX` bytes,\nor if the memory allocator reports failure."
      },
      "sortText": "7ffffffb",
      "filterText": "try_with_capacity",
      "textEdit": {
        "range": {
          "start": {
            "line": 20,
            "character": 8
          },
          "end": {
            "line": 20,
            "character": 12
          }
        },
        "newText": "try_with_capacity"
      }
    },
    {
      "label": "from_utf8",
      "kind": 3,
      "detail": "pub fn from_utf8(vec: Vec<u8>) -> Result<String, FromUtf8Error>",
      "documentation": {
        "kind": "markdown",
        "value": "Converts a vector of bytes to a `String`.\n\nA string ([`String`]) is made of bytes ([`u8`]), and a vector of bytes\n([`Vec<u8>`]) is made of bytes, so this function converts between the\ntwo. Not all byte slices are valid `String`s, however: `String`\nrequires that it is valid UTF-8. `from_utf8()` checks to ensure that\nthe bytes are valid UTF-8, and then does the conversion.\n\nIf you are sure that the byte slice is valid UTF-8, and you don't want\nto incur the overhead of the validity check, there is an unsafe version\nof this function, [`from_utf8_unchecked`], which has the same behavior\nbut skips the check.\n\nThis method will take care to not copy the vector, for efficiency's\nsake.\n\nIf you need a [`&str`] instead of a `String`, consider\n[`str::from_utf8`].\n\nThe inverse of this method is [`into_bytes`].\n\n# Errors\n\nReturns [`Err`] if the slice is not UTF-8 with a description as to why the\nprovided bytes are not UTF-8. The vector you moved in is also included.\n\n# Examples\n\nBasic usage:\n\n```rust\n// some bytes, in a vector\nlet sparkle_heart = vec![240, 159, 146, 150];\n\n// We know these bytes are valid, so we'll use `unwrap()`.\nlet sparkle_heart = String::from_utf8(sparkle_heart).unwrap();\n\nassert_eq!(\"💖\", sparkle_heart);\n```\n\nIncorrect bytes:\n\n```rust\n// some invalid bytes, in a vector\nlet sparkle_heart = vec![0, 159, 146, 150];\n\nassert!(String::from_utf8(sparkle_heart).is_err());\n```\n\nSee the docs for [`FromUtf8Error`] for more details on what you can do\nwith this error.\n\n[`from_utf8_unchecked`]: String::from_utf8_unchecked\n[`Vec<u8>`]: crate::vec::Vec \"Vec\"\n[`&str`]: prim@str \"&str\"\n[`into_bytes`]: String::into_bytes"
      },
      "sortText": "7ffffffb",
      "filterText": "from_utf8",
      "textEdit": {
        "range": {
          "start": {
            "line": 20,
            "character": 8
          },
          "end": {
            "line": 20,
            "character": 12
          }
        },
        "newText": "from_utf8"
      }
    },
    {
      "label": "from_utf8_lossy",
      "kind": 3,
      "detail": "pub fn from_utf8_lossy(v: &[u8]) -> Cow<'_, str>",
      "documentation": {
        "kind": "markdown",
        "value": "Converts a slice of bytes to a string, including invalid characters.\n\nStrings are made of bytes ([`u8`]), and a slice of bytes\n([`&[u8]`][byteslice]) is made of bytes, so this function converts\nbetween the two. Not all byte slices are valid strings, however: strings\nare required to be valid UTF-8. During this conversion,\n`from_utf8_lossy()` will replace any invalid UTF-8 sequences with\n[`U+FFFD REPLACEMENT CHARACTER`][U+FFFD], which looks like this: �\n\n[byteslice]: prim@slice\n[U+FFFD]: core::char::REPLACEMENT_CHARACTER\n\nIf you are sure that the byte slice is valid UTF-8, and you don't want\nto incur the overhead of the conversion, there is an unsafe version\nof this function, [`from_utf8_unchecked`], which has the same behavior\nbut skips the checks.\n\n[`from_utf8_unchecked`]: String::from_utf8_unchecked\n\nThis function returns a [`Cow<'a, str>`]. If our byte slice is invalid\nUTF-8, then we need to insert the replacement characters, which will\nchange the size of the string, and hence, require a `String`. But if\nit's already valid UTF-8, we don't need a new allocation. This return\ntype allows us to handle both cases.\n\n[`Cow<'a, str>`]: crate::borrow::Cow \"borrow::Cow\"\n\n# Examples\n\nBasic usage:\n\n```rust\n// some bytes, in a vector\nlet sparkle_heart = vec![240, 159, 146, 150];\n\nlet sparkle_heart = String::from_utf8_lossy(&sparkle_heart);\n\nassert_eq!(\"💖\", sparkle_heart);\n```\n\nIncorrect bytes:\n\n```rust\n// some invalid bytes\nlet input = b\"Hello \\xF0\\x90\\x80World\";\nlet output = String::from_utf8_lossy(input);\n\nassert_eq!(\"Hello �World\", output);\n```"
      },
      "sortText": "7fffffff",
      "filterText": "from_utf8_lossy",
      "textEdit": {
        "range": {
          "start": {
            "line": 20,
            "character": 8
          },
          "end": {
            "line": 20,
            "character": 12
          }
        },
        "newText": "from_utf8_lossy"
      }
    },
    {
      "label": "from_utf8_lossy_owned",
      "kind": 3,
      "detail": "pub fn from_utf8_lossy_owned(v: Vec<u8>) -> String",
      "documentation": {
        "kind": "markdown",
        "value": "Converts a [`Vec<u8>`] to a `String`, substituting invalid UTF-8\nsequences with replacement characters.\n\nSee [`from_utf8_lossy`] for more details.\n\n[`from_utf8_lossy`]: String::from_utf8_lossy\n\nNote that this function does not guarantee reuse of the original `Vec`\nallocation.\n\n# Examples\n\nBasic usage:\n\n```rust\n#![feature(string_from_utf8_lossy_owned)]\n// some bytes, in a vector\nlet sparkle_heart = vec![240, 159, 146, 150];\n\nlet sparkle_heart = String::from_utf8_lossy_owned(sparkle_heart);\n\nassert_eq!(String::from(\"💖\"), sparkle_heart);\n```\n\nIncorrect bytes:\n\n```rust\n#![feature(string_from_utf8_lossy_owned)]\n// some invalid bytes\nlet input: Vec<u8> = b\"Hello \\xF0\\x90\\x80World\".into();\nlet output = String::from_utf8_lossy_owned(input);\n\nassert_eq!(String::from(\"Hello �World\"), output);\n```"
      },
      "sortText": "7ffffff1",
      "filterText": "from_utf8_lossy_owned",
      "textEdit": {
        "range": {
          "start": {
            "line": 20,
            "character": 8
          },
          "end": {
            "line": 20,
            "character": 12
          }
        },
        "newText": "from_utf8_lossy_owned"
      }
    },
    {
      "label": "from_utf16",
      "kind": 3,
      "detail": "pub fn from_utf16(v: &[u16]) -> Result<String, FromUtf16Error>",
      "documentation": {
        "kind": "markdown",
        "value": "Decode a native endian UTF-16–encoded vector `v` into a `String`,\nreturning [`Err`] if `v` contains any invalid data.\n\n# Examples\n\n```rust\n// 𝄞music\nlet v = &[0xD834, 0xDD1E, 0x006d, 0x0075,\n          0x0073, 0x0069, 0x0063];\nassert_eq!(String::from(\"𝄞music\"),\n           String::from_utf16(v).unwrap());\n\n// 𝄞mu<invalid>ic\nlet v = &[0xD834, 0xDD1E, 0x006d, 0x0075,\n          0xD800, 0x0069, 0x0063];\nassert!(String::from_utf16(v).is_err());\n```"
      },
      "sortText": "7ffffffb",
      "filterText": "from_utf16",
      "textEdit": {
        "range": {
          "start": {
            "line": 20,
            "character": 8
          },
          "end": {
            "line": 20,
            "character": 12
          }
        },
        "newText": "from_utf16"
      }
    },
    {
      "label": "from_utf16_lossy",
      "kind": 3,
      "detail": "pub fn from_utf16_lossy(v: &[u16]) -> String",
      "documentation": {
        "kind": "markdown",
        "value": "Decode a native endian UTF-16–encoded slice `v` into a `String`,\nreplacing invalid data with [the replacement character (`U+FFFD`)][U+FFFD].\n\nUnlike [`from_utf8_lossy`] which returns a [`Cow<'a, str>`],\n`from_utf16_lossy` returns a `String` since the UTF-16 to UTF-8\nconversion requires a memory allocation.\n\n[`from_utf8_lossy`]: String::from_utf8_lossy\n[`Cow<'a, str>`]: crate::borrow::Cow \"borrow::Cow\"\n[U+FFFD]: core::char::REPLACEMENT_CHARACTER\n\n# Examples\n\n```rust\n// 𝄞mus<invalid>ic<invalid>\nlet v = &[0xD834, 0xDD1E, 0x006d, 0x0075,\n          0x0073, 0xDD1E, 0x0069, 0x0063,\n          0xD834];\n\nassert_eq!(String::from(\"𝄞mus\\u{FFFD}ic\\u{FFFD}\"),\n           String::from_utf16_lossy(v));\n```"
      },
      "sortText": "7ffffff1",
      "filterText": "from_utf16_lossy",
      "textEdit": {
        "range": {
          "start": {
            "line": 20,
            "character": 8
          },
          "end": {
            "line": 20,
            "character": 12
          }
        },
        "newText": "from_utf16_lossy"
      }
    },
    {
      "label": "from_utf16le",
      "kind": 3,
      "detail": "pub fn from_utf16le(v: &[u8]) -> Result<String, FromUtf16Error>",
      "documentation": {
        "kind": "markdown",
        "value": "Decode a UTF-16LE–encoded vector `v` into a `String`,\nreturning [`Err`] if `v` contains any invalid data.\n\n# Examples\n\nBasic usage:\n\n```rust\n#![feature(str_from_utf16_endian)]\n// 𝄞music\nlet v = &[0x34, 0xD8, 0x1E, 0xDD, 0x6d, 0x00, 0x75, 0x00,\n          0x73, 0x00, 0x69, 0x00, 0x63, 0x00];\nassert_eq!(String::from(\"𝄞music\"),\n           String::from_utf16le(v).unwrap());\n\n// 𝄞mu<invalid>ic\nlet v = &[0x34, 0xD8, 0x1E, 0xDD, 0x6d, 0x00, 0x75, 0x00,\n          0x00, 0xD8, 0x69, 0x00, 0x63, 0x00];\nassert!(String::from_utf16le(v).is_err());\n```"
      },
      "sortText": "7ffffffb",
      "filterText": "from_utf16le",
      "textEdit": {
        "range": {
          "start": {
            "line": 20,
            "character": 8
          },
          "end": {
            "line": 20,
            "character": 12
          }
        },
        "newText": "from_utf16le"
      }
    },
    {
      "label": "from_utf16le_lossy",
      "kind": 3,
      "detail": "pub fn from_utf16le_lossy(v: &[u8]) -> String",
      "documentation": {
        "kind": "markdown",
        "value": "Decode a UTF-16LE–encoded slice `v` into a `String`, replacing\ninvalid data with [the replacement character (`U+FFFD`)][U+FFFD].\n\nUnlike [`from_utf8_lossy`] which returns a [`Cow<'a, str>`],\n`from_utf16le_lossy` returns a `String` since the UTF-16 to UTF-8\nconversion requires a memory allocation.\n\n[`from_utf8_lossy`]: String::from_utf8_lossy\n[`Cow<'a, str>`]: crate::borrow::Cow \"borrow::Cow\"\n[U+FFFD]: core::char::REPLACEMENT_CHARACTER\n\n# Examples\n\nBasic usage:\n\n```rust\n#![feature(str_from_utf16_endian)]\n// 𝄞mus<invalid>ic<invalid>\nlet v = &[0x34, 0xD8, 0x1E, 0xDD, 0x6d, 0x00, 0x75, 0x00,\n          0x73, 0x00, 0x1E, 0xDD, 0x69, 0x00, 0x63, 0x00,\n          0x34, 0xD8];\n\nassert_eq!(String::from(\"𝄞mus\\u{FFFD}ic\\u{FFFD}\"),\n           String::from_utf16le_lossy(v));\n```"
      },
      "sortText": "7ffffff1",
      "filterText": "from_utf16le_lossy",
      "textEdit": {
        "range": {
          "start": {
            "line": 20,
            "character": 8
          },
          "end": {
            "line": 20,
            "character": 12
          }
        },
        "newText": "from_utf16le_lossy"
      }
    },
    {
      "label": "from_utf16be",
      "kind": 3,
      "detail": "pub fn from_utf16be(v: &[u8]) -> Result<String, FromUtf16Error>",
      "documentation": {
        "kind": "markdown",
        "value": "Decode a UTF-16BE–encoded vector `v` into a `String`,\nreturning [`Err`] if `v` contains any invalid data.\n\n# Examples\n\nBasic usage:\n\n```rust\n#![feature(str_from_utf16_endian)]\n// 𝄞music\nlet v = &[0xD8, 0x34, 0xDD, 0x1E, 0x00, 0x6d, 0x00, 0x75,\n          0x00, 0x73, 0x00, 0x69, 0x00, 0x63];\nassert_eq!(String::from(\"𝄞music\"),\n           String::from_utf16be(v).unwrap());\n\n// 𝄞mu<invalid>ic\nlet v = &[0xD8, 0x34, 0xDD, 0x1E, 0x00, 0x6d, 0x00, 0x75,\n          0xD8, 0x00, 0x00, 0x69, 0x00, 0x63];\nassert!(String::from_utf16be(v).is_err());\n```"
      },
      "sortText": "7ffffffb",
      "filterText": "from_utf16be",
      "textEdit": {
        "range": {
          "start": {
            "line": 20,
            "character": 8
          },
          "end": {
            "line": 20,
            "character": 12
          }
        },
        "newText": "from_utf16be"
      }
    },
    {
      "label": "from_utf16be_lossy",
      "kind": 3,
      "detail": "pub fn from_utf16be_lossy(v: &[u8]) -> String",
      "documentation": {
        "kind": "markdown",
        "value": "Decode a UTF-16BE–encoded slice `v` into a `String`, replacing\ninvalid data with [the replacement character (`U+FFFD`)][U+FFFD].\n\nUnlike [`from_utf8_lossy`] which returns a [`Cow<'a, str>`],\n`from_utf16le_lossy` returns a `String` since the UTF-16 to UTF-8\nconversion requires a memory allocation.\n\n[`from_utf8_lossy`]: String::from_utf8_lossy\n[`Cow<'a, str>`]: crate::borrow::Cow \"borrow::Cow\"\n[U+FFFD]: core::char::REPLACEMENT_CHARACTER\n\n# Examples\n\nBasic usage:\n\n```rust\n#![feature(str_from_utf16_endian)]\n// 𝄞mus<invalid>ic<invalid>\nlet v = &[0xD8, 0x34, 0xDD, 0x1E, 0x00, 0x6d, 0x00, 0x75,\n          0x00, 0x73, 0xDD, 0x1E, 0x00, 0x69, 0x00, 0x63,\n          0xD8, 0x34];\n\nassert_eq!(String::from(\"𝄞mus\\u{FFFD}ic\\u{FFFD}\"),\n           String::from_utf16be_lossy(v));\n```"
      },
      "sortText": "7ffffff1",
      "filterText": "from_utf16be_lossy",
      "textEdit": {
        "range": {
          "start": {
            "line": 20,
            "character": 8
          },
          "end": {
            "line": 20,
            "character": 12
          }
        },
        "newText": "from_utf16be_lossy"
      }
    },
    {
      "label": "into_raw_parts",
      "kind": 2,
      "detail": "pub fn into_raw_parts(self) -> (*mut u8, usize, usize)",
      "documentation": {
        "kind": "markdown",
        "value": "Decomposes a `String` into its raw components: `(pointer, length, capacity)`.\n\nReturns the raw pointer to the underlying data, the length of\nthe string (in bytes), and the allocated capacity of the data\n(in bytes). These are the same arguments in the same order as\nthe arguments to [`from_raw_parts`].\n\nAfter calling this function, the caller is responsible for the\nmemory previously managed by the `String`. The only way to do\nthis is to convert the raw pointer, length, and capacity back\ninto a `String` with the [`from_raw_parts`] function, allowing\nthe destructor to perform the cleanup.\n\n[`from_raw_parts`]: String::from_raw_parts\n\n# Examples\n\n```rust\n#![feature(vec_into_raw_parts)]\nlet s = String::from(\"hello\");\n\nlet (ptr, len, cap) = s.into_raw_parts();\n\nlet rebuilt = unsafe { String::from_raw_parts(ptr, len, cap) };\nassert_eq!(rebuilt, \"hello\");\n```"
      },
      "sortText": "7fffffff",
      "filterText": "into_raw_parts",
      "textEdit": {
        "range": {
          "start": {
            "line": 20,
            "character": 8
          },
          "end": {
            "line": 20,
            "character": 12
          }
        },
        "newText": "into_raw_parts"
      }
    },
    {
      "label": "from_raw_parts",
      "kind": 3,
      "detail": "pub unsafe fn from_raw_parts(buf: *mut u8, length: usize, capacity: usize) -> String",
      "documentation": {
        "kind": "markdown",
        "value": "Creates a new `String` from a pointer, a length and a capacity.\n\n# Safety\n\nThis is highly unsafe, due to the number of invariants that aren't\nchecked:\n\n* all safety requirements for [`Vec::<u8>::from_raw_parts`].\n* all safety requirements for [`String::from_utf8_unchecked`].\n\nViolating these may cause problems like corrupting the allocator's\ninternal data structures. For example, it is normally **not** safe to\nbuild a `String` from a pointer to a C `char` array containing UTF-8\n_unless_ you are certain that array was originally allocated by the\nRust standard library's allocator.\n\nThe ownership of `buf` is effectively transferred to the\n`String` which may then deallocate, reallocate or change the\ncontents of memory pointed to by the pointer at will. Ensure\nthat nothing else uses the pointer after calling this\nfunction.\n\n# Examples\n\n```rust\nuse std::mem;\n\nunsafe {\n    let s = String::from(\"hello\");\n\n    // Prevent automatically dropping the String's data\n    let mut s = mem::ManuallyDrop::new(s);\n\n    let ptr = s.as_mut_ptr();\n    let len = s.len();\n    let capacity = s.capacity();\n\n    let s = String::from_raw_parts(ptr, len, capacity);\n\n    assert_eq!(String::from(\"hello\"), s);\n}\n```"
      },
      "sortText": "7ffffff1",
      "filterText": "from_raw_parts",
      "textEdit": {
        "range": {
          "start": {
            "line": 20,
            "character": 8
          },
          "end": {
            "line": 20,
            "character": 12
          }
        },
        "newText": "from_raw_parts"
      }
    },
    {
      "label": "from_utf8_unchecked",
      "kind": 3,
      "detail": "pub unsafe fn from_utf8_unchecked(bytes: Vec<u8>) -> String",
      "documentation": {
        "kind": "markdown",
        "value": "Converts a vector of bytes to a `String` without checking that the\nstring contains valid UTF-8.\n\nSee the safe version, [`from_utf8`], for more details.\n\n[`from_utf8`]: String::from_utf8\n\n# Safety\n\nThis function is unsafe because it does not check that the bytes passed\nto it are valid UTF-8. If this constraint is violated, it may cause\nmemory unsafety issues with future users of the `String`, as the rest of\nthe standard library assumes that `String`s are valid UTF-8.\n\n# Examples\n\n```rust\n// some bytes, in a vector\nlet sparkle_heart = vec![240, 159, 146, 150];\n\nlet sparkle_heart = unsafe {\n    String::from_utf8_unchecked(sparkle_heart)\n};\n\nassert_eq!(\"💖\", sparkle_heart);\n```"
      },
      "sortText": "7ffffff1",
      "filterText": "from_utf8_unchecked",
      "textEdit": {
        "range": {
          "start": {
            "line": 20,
            "character": 8
          },
          "end": {
            "line": 20,
            "character": 12
          }
        },
        "newText": "from_utf8_unchecked"
      }
    },
    {
      "label": "into_bytes",
      "kind": 2,
      "detail": "pub const fn into_bytes(self) -> Vec<u8>",
      "documentation": {
        "kind": "markdown",
        "value": "Converts a `String` into a byte vector.\n\nThis consumes the `String`, so we do not need to copy its contents.\n\n# Examples\n\n```rust\nlet s = String::from(\"hello\");\nlet bytes = s.into_bytes();\n\nassert_eq!(&[104, 101, 108, 108, 111][..], &bytes[..]);\n```"
      },
      "sortText": "7fffffff",
      "filterText": "into_bytes",
      "textEdit": {
        "range": {
          "start": {
            "line": 20,
            "character": 8
          },
          "end": {
            "line": 20,
            "character": 12
          }
        },
        "newText": "into_bytes"
      }
    },
    {
      "label": "as_str",
      "kind": 2,
      "detail": "pub const fn as_str(&self) -> &str",
      "documentation": {
        "kind": "markdown",
        "value": "Extracts a string slice containing the entire `String`.\n\n# Examples\n\n```rust\nlet s = String::from(\"foo\");\n\nassert_eq!(\"foo\", s.as_str());\n```"
      },
      "sortText": "7fffffff",
      "filterText": "as_str",
      "textEdit": {
        "range": {
          "start": {
            "line": 20,
            "character": 8
          },
          "end": {
            "line": 20,
            "character": 12
          }
        },
        "newText": "as_str"
      }
    },
    {
      "label": "as_mut_str",
      "kind": 2,
      "detail": "pub const fn as_mut_str(&mut self) -> &mut str",
      "documentation": {
        "kind": "markdown",
        "value": "Converts a `String` into a mutable string slice.\n\n# Examples\n\n```rust\nlet mut s = String::from(\"foobar\");\nlet s_mut_str = s.as_mut_str();\n\ns_mut_str.make_ascii_uppercase();\n\nassert_eq!(\"FOOBAR\", s_mut_str);\n```"
      },
      "sortText": "7fffffff",
      "filterText": "as_mut_str",
      "textEdit": {
        "range": {
          "start": {
            "line": 20,
            "character": 8
          },
          "end": {
            "line": 20,
            "character": 12
          }
        },
        "newText": "as_mut_str"
      }
    },
    {
      "label": "push_str",
      "kind": 2,
      "detail": "pub fn push_str(&mut self, string: &str)",
      "documentation": {
        "kind": "markdown",
        "value": "Appends a given string slice onto the end of this `String`.\n\n# Examples\n\n```rust\nlet mut s = String::from(\"foo\");\n\ns.push_str(\"bar\");\n\nassert_eq!(\"foobar\", s);\n```"
      },
      "sortText": "7fffffff",
      "filterText": "push_str",
      "textEdit": {
        "range": {
          "start": {
            "line": 20,
            "character": 8
          },
          "end": {
            "line": 20,
            "character": 12
          }
        },
        "newText": "push_str"
      }
    },
    {
      "label": "extend_from_within",
      "kind": 2,
      "detail": "pub fn extend_from_within<R>(&mut self, src: R) where R: RangeBounds<usize>,",
      "documentation": {
        "kind": "markdown",
        "value": "Copies elements from `src` range to the end of the string.\n\n# Panics\n\nPanics if the range has `start_bound > end_bound`, or, if the range is\nbounded on either end and does not lie on a [`char`] boundary.\n\n# Examples\n\n```rust\nlet mut string = String::from(\"abcde\");\n\nstring.extend_from_within(2..);\nassert_eq!(string, \"abcdecde\");\n\nstring.extend_from_within(..2);\nassert_eq!(string, \"abcdecdeab\");\n\nstring.extend_from_within(4..8);\nassert_eq!(string, \"abcdecdeabecde\");\n```"
      },
      "sortText": "7fffffff",
      "filterText": "extend_from_within",
      "textEdit": {
        "range": {
          "start": {
            "line": 20,
            "character": 8
          },
          "end": {
            "line": 20,
            "character": 12
          }
        },
        "newText": "extend_from_within"
      }
    },
    {
      "label": "capacity",
      "kind": 2,
      "detail": "pub const fn capacity(&self) -> usize",
      "documentation": {
        "kind": "markdown",
        "value": "Returns this `String`'s capacity, in bytes.\n\n# Examples\n\n```rust\nlet s = String::with_capacity(10);\n\nassert!(s.capacity() >= 10);\n```"
      },
      "sortText": "7fffffff",
      "filterText": "capacity",
      "textEdit": {
        "range": {
          "start": {
            "line": 20,
            "character": 8
          },
          "end": {
            "line": 20,
            "character": 12
          }
        },
        "newText": "capacity"
      }
    },
    {
      "label": "reserve",
      "kind": 2,
      "detail": "pub fn reserve(&mut self, additional: usize)",
      "documentation": {
        "kind": "markdown",
        "value": "Reserves capacity for at least `additional` bytes more than the\ncurrent length. The allocator may reserve more space to speculatively\navoid frequent allocations. After calling `reserve`,\ncapacity will be greater than or equal to `self.len() + additional`.\nDoes nothing if capacity is already sufficient.\n\n# Panics\n\nPanics if the new capacity overflows [`usize`].\n\n# Examples\n\nBasic usage:\n\n```rust\nlet mut s = String::new();\n\ns.reserve(10);\n\nassert!(s.capacity() >= 10);\n```\n\nThis might not actually increase the capacity:\n\n```rust\nlet mut s = String::with_capacity(10);\ns.push('a');\ns.push('b');\n\n// s now has a length of 2 and a capacity of at least 10\nlet capacity = s.capacity();\nassert_eq!(2, s.len());\nassert!(capacity >= 10);\n\n// Since we already have at least an extra 8 capacity, calling this...\ns.reserve(8);\n\n// ... doesn't actually increase.\nassert_eq!(capacity, s.capacity());\n```"
      },
      "sortText": "7fffffff",
      "filterText": "reserve",
      "textEdit": {
        "range": {
          "start": {
            "line": 20,
            "character": 8
          },
          "end": {
            "line": 20,
            "character": 12
          }
        },
        "newText": "reserve"
      }
    },
    {
      "label": "reserve_exact",
      "kind": 2,
      "detail": "pub fn reserve_exact(&mut self, additional: usize)",
      "documentation": {
        "kind": "markdown",
        "value": "Reserves the minimum capacity for at least `additional` bytes more than\nthe current length. Unlike [`reserve`], this will not\ndeliberately over-allocate to speculatively avoid frequent allocations.\nAfter calling `reserve_exact`, capacity will be greater than or equal to\n`self.len() + additional`. Does nothing if the capacity is already\nsufficient.\n\n[`reserve`]: String::reserve\n\n# Panics\n\nPanics if the new capacity overflows [`usize`].\n\n# Examples\n\nBasic usage:\n\n```rust\nlet mut s = String::new();\n\ns.reserve_exact(10);\n\nassert!(s.capacity() >= 10);\n```\n\nThis might not actually increase the capacity:\n\n```rust\nlet mut s = String::with_capacity(10);\ns.push('a');\ns.push('b');\n\n// s now has a length of 2 and a capacity of at least 10\nlet capacity = s.capacity();\nassert_eq!(2, s.len());\nassert!(capacity >= 10);\n\n// Since we already have at least an extra 8 capacity, calling this...\ns.reserve_exact(8);\n\n// ... doesn't actually increase.\nassert_eq!(capacity, s.capacity());\n```"
      },
      "sortText": "7fffffff",
      "filterText": "reserve_exact",
      "textEdit": {
        "range": {
          "start": {
            "line": 20,
            "character": 8
          },
          "end": {
            "line": 20,
            "character": 12
          }
        },
        "newText": "reserve_exact"
      }
    },
    {
      "label": "try_reserve",
      "kind": 2,
      "detail": "pub fn try_reserve(&mut self, additional: usize) -> Result<(), TryReserveError>",
      "documentation": {
        "kind": "markdown",
        "value": "Tries to reserve capacity for at least `additional` bytes more than the\ncurrent length. The allocator may reserve more space to speculatively\navoid frequent allocations. After calling `try_reserve`, capacity will be\ngreater than or equal to `self.len() + additional` if it returns\n`Ok(())`. Does nothing if capacity is already sufficient. This method\npreserves the contents even if an error occurs.\n\n# Errors\n\nIf the capacity overflows, or the allocator reports a failure, then an error\nis returned.\n\n# Examples\n\n```rust\nuse std::collections::TryReserveError;\n\nfn process_data(data: &str) -> Result<String, TryReserveError> {\n    let mut output = String::new();\n\n    // Pre-reserve the memory, exiting if we can't\n    output.try_reserve(data.len())?;\n\n    // Now we know this can't OOM in the middle of our complex work\n    output.push_str(data);\n\n    Ok(output)\n}\n```"
      },
      "sortText": "7fffffff",
      "filterText": "try_reserve",
      "textEdit": {
        "range": {
          "start": {
            "line": 20,
            "character": 8
          },
          "end": {
            "line": 20,
            "character": 12
          }
        },
        "newText": "try_reserve"
      }
    },
    {
      "label": "try_reserve_exact",
      "kind": 2,
      "detail": "pub fn try_reserve_exact(&mut self, additional: usize) -> Result<(), TryReserveError>",
      "documentation": {
        "kind": "markdown",
        "value": "Tries to reserve the minimum capacity for at least `additional` bytes\nmore than the current length. Unlike [`try_reserve`], this will not\ndeliberately over-allocate to speculatively avoid frequent allocations.\nAfter calling `try_reserve_exact`, capacity will be greater than or\nequal to `self.len() + additional` if it returns `Ok(())`.\nDoes nothing if the capacity is already sufficient.\n\nNote that the allocator may give the collection more space than it\nrequests. Therefore, capacity can not be relied upon to be precisely\nminimal. Prefer [`try_reserve`] if future insertions are expected.\n\n[`try_reserve`]: String::try_reserve\n\n# Errors\n\nIf the capacity overflows, or the allocator reports a failure, then an error\nis returned.\n\n# Examples\n\n```rust\nuse std::collections::TryReserveError;\n\nfn process_data(data: &str) -> Result<String, TryReserveError> {\n    let mut output = String::new();\n\n    // Pre-reserve the memory, exiting if we can't\n    output.try_reserve_exact(data.len())?;\n\n    // Now we know this can't OOM in the middle of our complex work\n    output.push_str(data);\n\n    Ok(output)\n}\n```"
      },
      "sortText": "7fffffff",
      "filterText": "try_reserve_exact",
      "textEdit": {
        "range": {
          "start": {
            "line": 20,
            "character": 8
          },
          "end": {
            "line": 20,
            "character": 12
          }
        },
        "newText": "try_reserve_exact"
      }
    },
    {
      "label": "shrink_to_fit",
      "kind": 2,
      "detail": "pub fn shrink_to_fit(&mut self)",
      "documentation": {
        "kind": "markdown",
        "value": "Shrinks the capacity of this `String` to match its length.\n\n# Examples\n\n```rust\nlet mut s = String::from(\"foo\");\n\ns.reserve(100);\nassert!(s.capacity() >= 100);\n\ns.shrink_to_fit();\nassert_eq!(3, s.capacity());\n```"
      },
      "sortText": "7fffffff",
      "filterText": "shrink_to_fit",
      "textEdit": {
        "range": {
          "start": {
            "line": 20,
            "character": 8
          },
          "end": {
            "line": 20,
            "character": 12
          }
        },
        "newText": "shrink_to_fit"
      }
    },
    {
      "label": "shrink_to",
      "kind": 2,
      "detail": "pub fn shrink_to(&mut self, min_capacity: usize)",
      "documentation": {
        "kind": "markdown",
        "value": "Shrinks the capacity of this `String` with a lower bound.\n\nThe capacity will remain at least as large as both the length\nand the supplied value.\n\nIf the current capacity is less than the lower limit, this is a no-op.\n\n# Examples\n\n```rust\nlet mut s = String::from(\"foo\");\n\ns.reserve(100);\nassert!(s.capacity() >= 100);\n\ns.shrink_to(10);\nassert!(s.capacity() >= 10);\ns.shrink_to(0);\nassert!(s.capacity() >= 3);\n```"
      },
      "sortText": "7fffffff",
      "filterText": "shrink_to",
      "textEdit": {
        "range": {
          "start": {
            "line": 20,
            "character": 8
          },
          "end": {
            "line": 20,
            "character": 12
          }
        },
        "newText": "shrink_to"
      }
    },
    {
      "label": "push",
      "kind": 2,
      "detail": "pub fn push(&mut self, ch: char)",
      "documentation": {
        "kind": "markdown",
        "value": "Appends the given [`char`] to the end of this `String`.\n\n# Examples\n\n```rust\nlet mut s = String::from(\"abc\");\n\ns.push('1');\ns.push('2');\ns.push('3');\n\nassert_eq!(\"abc123\", s);\n```"
      },
      "sortText": "7fffffff",
      "filterText": "push",
      "textEdit": {
        "range": {
          "start": {
            "line": 20,
            "character": 8
          },
          "end": {
            "line": 20,
            "character": 12
          }
        },
        "newText": "push"
      }
    },
    {
      "label": "as_bytes",
      "kind": 2,
      "detail": "pub const fn as_bytes(&self) -> &[u8]",
      "documentation": {
        "kind": "markdown",
        "value": "Returns a byte slice of this `String`'s contents.\n\nThe inverse of this method is [`from_utf8`].\n\n[`from_utf8`]: String::from_utf8\n\n# Examples\n\n```rust\nlet s = String::from(\"hello\");\n\nassert_eq!(&[104, 101, 108, 108, 111], s.as_bytes());\n```"
      },
      "sortText": "7fffffff",
      "filterText": "as_bytes",
      "textEdit": {
        "range": {
          "start": {
            "line": 20,
            "character": 8
          },
          "end": {
            "line": 20,
            "character": 12
          }
        },
        "newText": "as_bytes"
      }
    },
    {
      "label": "truncate",
      "kind": 2,
      "detail": "pub fn truncate(&mut self, new_len: usize)",
      "documentation": {
        "kind": "markdown",
        "value": "Shortens this `String` to the specified length.\n\nIf `new_len` is greater than or equal to the string's current length, this has no\neffect.\n\nNote that this method has no effect on the allocated capacity\nof the string\n\n# Panics\n\nPanics if `new_len` does not lie on a [`char`] boundary.\n\n# Examples\n\n```rust\nlet mut s = String::from(\"hello\");\n\ns.truncate(2);\n\nassert_eq!(\"he\", s);\n```"
      },
      "sortText": "7fffffff",
      "filterText": "truncate",
      "textEdit": {
        "range": {
          "start": {
            "line": 20,
            "character": 8
          },
          "end": {
            "line": 20,
            "character": 12
          }
        },
        "newText": "truncate"
      }
    },
    {
      "label": "pop",
      "kind": 2,
      "detail": "pub fn pop(&mut self) -> Option<char>",
      "documentation": {
        "kind": "markdown",
        "value": "Removes the last character from the string buffer and returns it.\n\nReturns [`None`] if this `String` is empty.\n\n# Examples\n\n```rust\nlet mut s = String::from(\"abč\");\n\nassert_eq!(s.pop(), Some('č'));\nassert_eq!(s.pop(), Some('b'));\nassert_eq!(s.pop(), Some('a'));\n\nassert_eq!(s.pop(), None);\n```"
      },
      "sortText": "7fffffff",
      "filterText": "pop",
      "textEdit": {
        "range": {
          "start": {
            "line": 20,
            "character": 8
          },
          "end": {
            "line": 20,
            "character": 12
          }
        },
        "newText": "pop"
      }
    },
    {
      "label": "remove",
      "kind": 2,
      "detail": "pub fn remove(&mut self, idx: usize) -> char",
      "documentation": {
        "kind": "markdown",
        "value": "Removes a [`char`] from this `String` at byte position `idx` and returns it.\n\nCopies all bytes after the removed char to new positions.\n\nNote that calling this in a loop can result in quadratic behavior.\n\n# Panics\n\nPanics if `idx` is larger than or equal to the `String`'s length,\nor if it does not lie on a [`char`] boundary.\n\n# Examples\n\n```rust\nlet mut s = String::from(\"abç\");\n\nassert_eq!(s.remove(0), 'a');\nassert_eq!(s.remove(1), 'ç');\nassert_eq!(s.remove(0), 'b');\n```"
      },
      "sortText": "7fffffff",
      "filterText": "remove",
      "textEdit": {
        "range": {
          "start": {
            "line": 20,
            "character": 8
          },
          "end": {
            "line": 20,
            "character": 12
          }
        },
        "newText": "remove"
      }
    },
    {
      "label": "remove_matches",
      "kind": 2,
      "detail": "pub fn remove_matches<P>(&mut self, pat: P) where P: Pattern,",
      "documentation": {
        "kind": "markdown",
        "value": "Remove all matches of pattern `pat` in the `String`.\n\n# Examples\n\n```rust\n#![feature(string_remove_matches)]\nlet mut s = String::from(\"Trees are not green, the sky is not blue.\");\ns.remove_matches(\"not \");\nassert_eq!(\"Trees are green, the sky is blue.\", s);\n```\n\nMatches will be detected and removed iteratively, so in cases where\npatterns overlap, only the first pattern will be removed:\n\n```rust\n#![feature(string_remove_matches)]\nlet mut s = String::from(\"banana\");\ns.remove_matches(\"ana\");\nassert_eq!(\"bna\", s);\n```"
      },
      "sortText": "7fffffff",
      "filterText": "remove_matches",
      "textEdit": {
        "range": {
          "start": {
            "line": 20,
            "character": 8
          },
          "end": {
            "line": 20,
            "character": 12
          }
        },
        "newText": "remove_matches"
      }
    },
    {
      "label": "retain",
      "kind": 2,
      "detail": "pub fn retain<F>(&mut self, mut f: F) where F: FnMut(char) -> bool,",
      "documentation": {
        "kind": "markdown",
        "value": "Retains only the characters specified by the predicate.\n\nIn other words, remove all characters `c` such that `f(c)` returns `false`.\nThis method operates in place, visiting each character exactly once in the\noriginal order, and preserves the order of the retained characters.\n\n# Examples\n\n```rust\nlet mut s = String::from(\"f_o_ob_ar\");\n\ns.retain(|c| c != '_');\n\nassert_eq!(s, \"foobar\");\n```\n\nBecause the elements are visited exactly once in the original order,\nexternal state may be used to decide which elements to keep.\n\n```rust\nlet mut s = String::from(\"abcde\");\nlet keep = [false, true, true, false, true];\nlet mut iter = keep.iter();\ns.retain(|_| *iter.next().unwrap());\nassert_eq!(s, \"bce\");\n```"
      },
      "sortText": "7fffffff",
      "filterText": "retain",
      "textEdit": {
        "range": {
          "start": {
            "line": 20,
            "character": 8
          },
          "end": {
            "line": 20,
            "character": 12
          }
        },
        "newText": "retain"
      }
    },
    {
      "label": "insert",
      "kind": 2,
      "detail": "pub fn insert(&mut self, idx: usize, ch: char)",
      "documentation": {
        "kind": "markdown",
        "value": "Inserts a character into this `String` at byte position `idx`.\n\nReallocates if `self.capacity()` is insufficient, which may involve copying all\n`self.capacity()` bytes. Makes space for the insertion by copying all bytes of\n`&self[idx..]` to new positions.\n\nNote that calling this in a loop can result in quadratic behavior.\n\n# Panics\n\nPanics if `idx` is larger than the `String`'s length, or if it does not\nlie on a [`char`] boundary.\n\n# Examples\n\n```rust\nlet mut s = String::with_capacity(3);\n\ns.insert(0, 'f');\ns.insert(1, 'o');\ns.insert(2, 'o');\n\nassert_eq!(\"foo\", s);\n```"
      },
      "sortText": "7fffffff",
      "filterText": "insert",
      "textEdit": {
        "range": {
          "start": {
            "line": 20,
            "character": 8
          },
          "end": {
            "line": 20,
            "character": 12
          }
        },
        "newText": "insert"
      }
    },
    {
      "label": "insert_str",
      "kind": 2,
      "detail": "pub fn insert_str(&mut self, idx: usize, string: &str)",
      "documentation": {
        "kind": "markdown",
        "value": "Inserts a string slice into this `String` at byte position `idx`.\n\nReallocates if `self.capacity()` is insufficient, which may involve copying all\n`self.capacity()` bytes. Makes space for the insertion by copying all bytes of\n`&self[idx..]` to new positions.\n\nNote that calling this in a loop can result in quadratic behavior.\n\n# Panics\n\nPanics if `idx` is larger than the `String`'s length, or if it does not\nlie on a [`char`] boundary.\n\n# Examples\n\n```rust\nlet mut s = String::from(\"bar\");\n\ns.insert_str(0, \"foo\");\n\nassert_eq!(\"foobar\", s);\n```"
      },
      "sortText": "7fffffff",
      "filterText": "insert_str",
      "textEdit": {
        "range": {
          "start": {
            "line": 20,
            "character": 8
          },
          "end": {
            "line": 20,
            "character": 12
          }
        },
        "newText": "insert_str"
      }
    },
    {
      "label": "as_mut_vec",
      "kind": 2,
      "detail": "pub const unsafe fn as_mut_vec(&mut self) -> &mut Vec<u8>",
      "documentation": {
        "kind": "markdown",
        "value": "Returns a mutable reference to the contents of this `String`.\n\n# Safety\n\nThis function is unsafe because the returned `&mut Vec` allows writing\nbytes which are not valid UTF-8. If this constraint is violated, using\nthe original `String` after dropping the `&mut Vec` may violate memory\nsafety, as the rest of the standard library assumes that `String`s are\nvalid UTF-8.\n\n# Examples\n\n```rust\nlet mut s = String::from(\"hello\");\n\nunsafe {\n    let vec = s.as_mut_vec();\n    assert_eq!(&[104, 101, 108, 108, 111][..], &vec[..]);\n\n    vec.reverse();\n}\nassert_eq!(s, \"olleh\");\n```"
      },
      "sortText": "7fffffff",
      "filterText": "as_mut_vec",
      "textEdit": {
        "range": {
          "start": {
            "line": 20,
            "character": 8
          },
          "end": {
            "line": 20,
            "character": 12
          }
        },
        "newText": "as_mut_vec"
      }
    },
    {
      "label": "len",
      "kind": 2,
      "detail": "pub const fn len(&self) -> usize",
      "documentation": {
        "kind": "markdown",
        "value": "Returns the length of this `String`, in bytes, not [`char`]s or\ngraphemes. In other words, it might not be what a human considers the\nlength of the string.\n\n# Examples\n\n```rust\nlet a = String::from(\"foo\");\nassert_eq!(a.len(), 3);\n\nlet fancy_f = String::from(\"ƒoo\");\nassert_eq!(fancy_f.len(), 4);\nassert_eq!(fancy_f.chars().count(), 3);\n```"
      },
      "sortText": "7fffffff",
      "filterText": "len",
      "textEdit": {
        "range": {
          "start": {
            "line": 20,
            "character": 8
          },
          "end": {
            "line": 20,
            "character": 12
          }
        },
        "newText": "len"
      }
    },
    {
      "label": "is_empty",
      "kind": 2,
      "detail": "pub const fn is_empty(&self) -> bool",
      "documentation": {
        "kind": "markdown",
        "value": "Returns `true` if this `String` has a length of zero, and `false` otherwise.\n\n# Examples\n\n```rust\nlet mut v = String::new();\nassert!(v.is_empty());\n\nv.push('a');\nassert!(!v.is_empty());\n```"
      },
      "sortText": "7fffffff",
      "filterText": "is_empty",
      "textEdit": {
        "range": {
          "start": {
            "line": 20,
            "character": 8
          },
          "end": {
            "line": 20,
            "character": 12
          }
        },
        "newText": "is_empty"
      }
    },
    {
      "label": "split_off",
      "kind": 2,
      "detail": "pub fn split_off(&mut self, at: usize) -> String",
      "documentation": {
        "kind": "markdown",
        "value": "Splits the string into two at the given byte index.\n\nReturns a newly allocated `String`. `self` contains bytes `[0, at)`, and\nthe returned `String` contains bytes `[at, len)`. `at` must be on the\nboundary of a UTF-8 code point.\n\nNote that the capacity of `self` does not change.\n\n# Panics\n\nPanics if `at` is not on a `UTF-8` code point boundary, or if it is beyond the last\ncode point of the string.\n\n# Examples\n\n```rust\nlet mut hello = String::from(\"Hello, World!\");\nlet world = hello.split_off(7);\nassert_eq!(hello, \"Hello, \");\nassert_eq!(world, \"World!\");\n```"
      },
      "sortText": "7ffffff1",
      "filterText": "split_off",
      "textEdit": {
        "range": {
          "start": {
            "line": 20,
            "character": 8
          },
          "end": {
            "line": 20,
            "character": 12
          }
        },
        "newText": "split_off"
      }
    },
    {
      "label": "clear",
      "kind": 2,
      "detail": "pub fn clear(&mut self)",
      "documentation": {
        "kind": "markdown",
        "value": "Truncates this `String`, removing all contents.\n\nWhile this means the `String` will have a length of zero, it does not\ntouch its capacity.\n\n# Examples\n\n```rust\nlet mut s = String::from(\"foo\");\n\ns.clear();\n\nassert!(s.is_empty());\nassert_eq!(0, s.len());\nassert_eq!(3, s.capacity());\n```"
      },
      "sortText": "7fffffff",
      "filterText": "clear",
      "textEdit": {
        "range": {
          "start": {
            "line": 20,
            "character": 8
          },
          "end": {
            "line": 20,
            "character": 12
          }
        },
        "newText": "clear"
      }
    },
    {
      "label": "drain",
      "kind": 2,
      "detail": "pub fn drain<R>(&mut self, range: R) -> Drain<'_> where R: RangeBounds<usize>,",
      "documentation": {
        "kind": "markdown",
        "value": "Removes the specified range from the string in bulk, returning all\nremoved characters as an iterator.\n\nThe returned iterator keeps a mutable borrow on the string to optimize\nits implementation.\n\n# Panics\n\nPanics if the range has `start_bound > end_bound`, or, if the range is\nbounded on either end and does not lie on a [`char`] boundary.\n\n# Leaking\n\nIf the returned iterator goes out of scope without being dropped (due to\n[`core::mem::forget`], for example), the string may still contain a copy\nof any drained characters, or may have lost characters arbitrarily,\nincluding characters outside the range.\n\n# Examples\n\n```rust\nlet mut s = String::from(\"α is alpha, β is beta\");\nlet beta_offset = s.find('β').unwrap_or(s.len());\n\n// Remove the range up until the β from the string\nlet t: String = s.drain(..beta_offset).collect();\nassert_eq!(t, \"α is alpha, \");\nassert_eq!(s, \"β is beta\");\n\n// A full range clears the string, like `clear()` does\ns.drain(..);\nassert_eq!(s, \"\");\n```"
      },
      "sortText": "7fffffff",
      "filterText": "drain",
      "textEdit": {
        "range": {
          "start": {
            "line": 20,
            "character": 8
          },
          "end": {
            "line": 20,
            "character": 12
          }
        },
        "newText": "drain"
      }
    },
    {
      "label": "into_chars",
      "kind": 2,
      "detail": "pub fn into_chars(self) -> IntoChars",
      "documentation": {
        "kind": "markdown",
        "value": "Converts a `String` into an iterator over the [`char`]s of the string.\n\nAs a string consists of valid UTF-8, we can iterate through a string\nby [`char`]. This method returns such an iterator.\n\nIt's important to remember that [`char`] represents a Unicode Scalar\nValue, and might not match your idea of what a 'character' is. Iteration\nover grapheme clusters may be what you actually want. That functionality\nis not provided by Rust's standard library, check crates.io instead.\n\n# Examples\n\nBasic usage:\n\n```rust\n#![feature(string_into_chars)]\n\nlet word = String::from(\"goodbye\");\n\nlet mut chars = word.into_chars();\n\nassert_eq!(Some('g'), chars.next());\nassert_eq!(Some('o'), chars.next());\nassert_eq!(Some('o'), chars.next());\nassert_eq!(Some('d'), chars.next());\nassert_eq!(Some('b'), chars.next());\nassert_eq!(Some('y'), chars.next());\nassert_eq!(Some('e'), chars.next());\n\nassert_eq!(None, chars.next());\n```\n\nRemember, [`char`]s might not match your intuition about characters:\n\n```rust\n#![feature(string_into_chars)]\n\nlet y = String::from(\"y̆\");\n\nlet mut chars = y.into_chars();\n\nassert_eq!(Some('y'), chars.next()); // not 'y̆'\nassert_eq!(Some('\\u{0306}'), chars.next());\n\nassert_eq!(None, chars.next());\n```\n\n[`char`]: prim@char"
      },
      "sortText": "7fffffff",
      "filterText": "into_chars",
      "textEdit": {
        "range": {
          "start": {
            "line": 20,
            "character": 8
          },
          "end": {
            "line": 20,
            "character": 12
          }
        },
        "newText": "into_chars"
      }
    },
    {
      "label": "replace_range",
      "kind": 2,
      "detail": "pub fn replace_range<R>(&mut self, range: R, replace_with: &str) where R: RangeBounds<usize>,",
      "documentation": {
        "kind": "markdown",
        "value": "Removes the specified range in the string,\nand replaces it with the given string.\nThe given string doesn't need to be the same length as the range.\n\n# Panics\n\nPanics if the range has `start_bound > end_bound`, or, if the range is\nbounded on either end and does not lie on a [`char`] boundary.\n\n# Examples\n\n```rust\nlet mut s = String::from(\"α is alpha, β is beta\");\nlet beta_offset = s.find('β').unwrap_or(s.len());\n\n// Replace the range up until the β from the string\ns.replace_range(..beta_offset, \"Α is capital alpha; \");\nassert_eq!(s, \"Α is capital alpha; β is beta\");\n```"
      },
      "sortText": "7fffffff",
      "filterText": "replace_range",
      "textEdit": {
        "range": {
          "start": {
            "line": 20,
            "character": 8
          },
          "end": {
            "line": 20,
            "character": 12
          }
        },
        "newText": "replace_range"
      }
    },
    {
      "label": "into_boxed_str",
      "kind": 2,
      "detail": "pub fn into_boxed_str(self) -> Box<str>",
      "documentation": {
        "kind": "markdown",
        "value": "Converts this `String` into a <code>[Box]<[str]></code>.\n\nBefore doing the conversion, this method discards excess capacity like [`shrink_to_fit`].\nNote that this call may reallocate and copy the bytes of the string.\n\n[`shrink_to_fit`]: String::shrink_to_fit\n[str]: prim@str \"str\"\n\n# Examples\n\n```rust\nlet s = String::from(\"hello\");\n\nlet b = s.into_boxed_str();\n```"
      },
      "sortText": "7fffffff",
      "filterText": "into_boxed_str",
      "textEdit": {
        "range": {
          "start": {
            "line": 20,
            "character": 8
          },
          "end": {
            "line": 20,
            "character": 12
          }
        },
        "newText": "into_boxed_str"
      }
    },
    {
      "label": "leak",
      "kind": 2,
      "detail": "pub fn leak<'a>(self) -> &'a mut str",
      "documentation": {
        "kind": "markdown",
        "value": "Consumes and leaks the `String`, returning a mutable reference to the contents,\n`&'a mut str`.\n\nThe caller has free choice over the returned lifetime, including `'static`. Indeed,\nthis function is ideally used for data that lives for the remainder of the program's life,\nas dropping the returned reference will cause a memory leak.\n\nIt does not reallocate or shrink the `String`, so the leaked allocation may include unused\ncapacity that is not part of the returned slice. If you want to discard excess capacity,\ncall [`into_boxed_str`], and then [`Box::leak`] instead. However, keep in mind that\ntrimming the capacity may result in a reallocation and copy.\n\n[`into_boxed_str`]: Self::into_boxed_str\n\n# Examples\n\n```rust\nlet x = String::from(\"bucket\");\nlet static_ref: &'static mut str = x.leak();\nassert_eq!(static_ref, \"bucket\");\n```"
      },
      "sortText": "7fffffff",
      "filterText": "leak",
      "textEdit": {
        "range": {
          "start": {
            "line": 20,
            "character": 8
          },
          "end": {
            "line": 20,
            "character": 12
          }
        },
        "newText": "leak"
      }
    },
    {
      "label": "to_owned(as ToOwned)",
      "kind": 2,
      "detail": "pub fn to_owned(&self) -> Self::Owned",
      "documentation": {
        "kind": "markdown",
        "value": "Creates owned data from borrowed data, usually by cloning.\n\n# Examples\n\nBasic usage:\n\n```rust\nlet s: &str = \"a\";\nlet ss: String = s.to_owned();\n\nlet v: &[i32] = &[1, 2];\nlet vv: Vec<i32> = v.to_owned();\n```"
      },
      "sortText": "80000004",
      "filterText": "to_owned",
      "textEdit": {
        "range": {
          "start": {
            "line": 20,
            "character": 8
          },
          "end": {
            "line": 20,
            "character": 12
          }
        },
        "newText": "to_owned"
      }
    },
    {
      "label": "clone_into(as ToOwned)",
      "kind": 2,
      "detail": "pub fn clone_into(&self, target: &mut Self::Owned)",
      "documentation": {
        "kind": "markdown",
        "value": "Uses borrowed data to replace owned data, usually by cloning.\n\nThis is borrow-generalized version of [`Clone::clone_from`].\n\n# Examples\n\nBasic usage:\n\n```rust\nlet mut s: String = String::new();\n\"hello\".clone_into(&mut s);\n\nlet mut v: Vec<i32> = Vec::new();\n[1, 2][..].clone_into(&mut v);\n```"
      },
      "sortText": "80000004",
      "filterText": "clone_into",
      "textEdit": {
        "range": {
          "start": {
            "line": 20,
            "character": 8
          },
          "end": {
            "line": 20,
            "character": 12
          }
        },
        "newText": "clone_into"
      }
    },
    {
      "label": "extend(as Extend)",
      "kind": 2,
      "detail": "pub fn extend<T>(&mut self, iter: T) where T: IntoIterator<Item = A>,",
      "documentation": {
        "kind": "markdown",
        "value": "Extends a collection with the contents of an iterator.\n\nAs this is the only required method for this trait, the [trait-level] docs\ncontain more details.\n\n[trait-level]: Extend\n\n# Examples\n\n```rust\n// You can extend a String with some chars:\nlet mut message = String::from(\"abc\");\n\nmessage.extend(['d', 'e', 'f'].iter());\n\nassert_eq!(\"abcdef\", &message);\n```"
      },
      "sortText": "80000004",
      "filterText": "extend",
      "textEdit": {
        "range": {
          "start": {
            "line": 20,
            "character": 8
          },
          "end": {
            "line": 20,
            "character": 12
          }
        },
        "newText": "extend"
      }
    },
    {
      "label": "extend_one(as Extend)",
      "kind": 2,
      "detail": "pub fn extend_one(&mut self, item: A)",
      "documentation": {
        "kind": "markdown",
        "value": "Extends a collection with exactly one element."
      },
      "sortText": "80000004",
      "filterText": "extend_one",
      "textEdit": {
        "range": {
          "start": {
            "line": 20,
            "character": 8
          },
          "end": {
            "line": 20,
            "character": 12
          }
        },
        "newText": "extend_one"
      }
    },
    {
      "label": "extend_reserve(as Extend)",
      "kind": 2,
      "detail": "pub fn extend_reserve(&mut self, additional: usize)",
      "documentation": {
        "kind": "markdown",
        "value": "Reserves capacity in a collection for the given number of additional elements.\n\nThe default implementation does nothing."
      },
      "sortText": "80000004",
      "filterText": "extend_reserve",
      "textEdit": {
        "range": {
          "start": {
            "line": 20,
            "character": 8
          },
          "end": {
            "line": 20,
            "character": 12
          }
        },
        "newText": "extend_reserve"
      }
    },
    {
      "label": "into(as Into)",
      "kind": 2,
      "detail": "pub fn into(self) -> T",
      "documentation": {
        "kind": "markdown",
        "value": "Converts this type into the (usually inferred) input type."
      },
      "sortText": "80000004",
      "filterText": "into",
      "textEdit": {
        "range": {
          "start": {
            "line": 20,
            "character": 8
          },
          "end": {
            "line": 20,
            "character": 12
          }
        },
        "newText": "into"
      }
    },
    {
      "label": "to_string(as ToString)",
      "kind": 2,
      "detail": "pub fn to_string(&self) -> String",
      "documentation": {
        "kind": "markdown",
        "value": "Converts the given value to a `String`.\n\n# Examples\n\n```rust\nlet i = 5;\nlet five = String::from(\"5\");\n\nassert_eq!(five, i.to_string());\n```"
      },
      "sortText": "80000004",
      "filterText": "to_string",
      "textEdit": {
        "range": {
          "start": {
            "line": 20,
            "character": 8
          },
          "end": {
            "line": 20,
            "character": 12
          }
        },
        "newText": "to_string"
      }
    },
    {
      "label": "try_from(as TryFrom)",
      "kind": 3,
      "detail": "pub fn try_from(value: T) -> Result<Self, Self::Error>",
      "documentation": {
        "kind": "markdown",
        "value": "Performs the conversion."
      },
      "sortText": "80000004",
      "filterText": "try_from",
      "textEdit": {
        "range": {
          "start": {
            "line": 20,
            "character": 8
          },
          "end": {
            "line": 20,
            "character": 12
          }
        },
        "newText": "try_from"
      }
    },
    {
      "label": "from_iter(as FromIterator)",
      "kind": 3,
      "detail": "pub fn from_iter<T>(iter: T) -> Self where T: IntoIterator<Item = A>,",
      "documentation": {
        "kind": "markdown",
        "value": "Creates a value from an iterator.\n\nSee the [module-level documentation] for more.\n\n[module-level documentation]: crate::iter\n\n# Examples\n\n```rust\nlet five_fives = std::iter::repeat(5).take(5);\n\nlet v = Vec::from_iter(five_fives);\n\nassert_eq!(v, vec![5, 5, 5, 5, 5]);\n```"
      },
      "sortText": "80000004",
      "filterText": "from_iter",
      "textEdit": {
        "range": {
          "start": {
            "line": 20,
            "character": 8
          },
          "end": {
            "line": 20,
            "character": 12
          }
        },
        "newText": "from_iter"
      }
    },
    {
      "label": "as_mut(as AsMut)",
      "kind": 2,
      "detail": "pub fn as_mut(&mut self) -> &mut T",
      "documentation": {
        "kind": "markdown",
        "value": "Converts this type into a mutable reference of the (usually inferred) input type."
      },
      "sortText": "80000004",
      "filterText": "as_mut",
      "textEdit": {
        "range": {
          "start": {
            "line": 20,
            "character": 8
          },
          "end": {
            "line": 20,
            "character": 12
          }
        },
        "newText": "as_mut"
      }
    },
    {
      "label": "try_into(as TryInto)",
      "kind": 2,
      "detail": "pub fn try_into(self) -> Result<T, Self::Error>",
      "documentation": {
        "kind": "markdown",
        "value": "Performs the conversion."
      },
      "sortText": "80000004",
      "filterText": "try_into",
      "textEdit": {
        "range": {
          "start": {
            "line": 20,
            "character": 8
          },
          "end": {
            "line": 20,
            "character": 12
          }
        },
        "newText": "try_into"
      }
    },
    {
      "label": "eq(as PartialEq)",
      "kind": 2,
      "detail": "pub fn eq(&self, other: &Rhs) -> bool",
      "documentation": {
        "kind": "markdown",
        "value": "Tests for `self` and `other` values to be equal, and is used by `==`."
      },
      "sortText": "80000009",
      "filterText": "eq",
      "textEdit": {
        "range": {
          "start": {
            "line": 20,
            "character": 8
          },
          "end": {
            "line": 20,
            "character": 12
          }
        },
        "newText": "eq"
      }
    },
    {
      "label": "ne(as PartialEq)",
      "kind": 2,
      "detail": "pub fn ne(&self, other: &Rhs) -> bool",
      "documentation": {
        "kind": "markdown",
        "value": "Tests for `!=`. The default implementation is almost always sufficient,\nand should not be overridden without very good reason."
      },
      "sortText": "80000009",
      "filterText": "ne",
      "textEdit": {
        "range": {
          "start": {
            "line": 20,
            "character": 8
          },
          "end": {
            "line": 20,
            "character": 12
          }
        },
        "newText": "ne"
      }
    },
    {
      "label": "partial_cmp(as PartialOrd)",
      "kind": 2,
      "detail": "pub fn partial_cmp(&self, other: &Rhs) -> Option<Ordering>",
      "documentation": {
        "kind": "markdown",
        "value": "This method returns an ordering between `self` and `other` values if one exists.\n\n# Examples\n\n```rust\nuse std::cmp::Ordering;\n\nlet result = 1.0.partial_cmp(&2.0);\nassert_eq!(result, Some(Ordering::Less));\n\nlet result = 1.0.partial_cmp(&1.0);\nassert_eq!(result, Some(Ordering::Equal));\n\nlet result = 2.0.partial_cmp(&1.0);\nassert_eq!(result, Some(Ordering::Greater));\n```\n\nWhen comparison is impossible:\n\n```rust\nlet result = f64::NAN.partial_cmp(&1.0);\nassert_eq!(result, None);\n```"
      },
      "sortText": "80000009",
      "filterText": "partial_cmp",
      "textEdit": {
        "range": {
          "start": {
            "line": 20,
            "character": 8
          },
          "end": {
            "line": 20,
            "character": 12
          }
        },
        "newText": "partial_cmp"
      }
    },
    {
      "label": "lt(as PartialOrd)",
      "kind": 2,
      "detail": "pub fn lt(&self, other: &Rhs) -> bool",
      "documentation": {
        "kind": "markdown",
        "value": "Tests less than (for `self` and `other`) and is used by the `<` operator.\n\n# Examples\n\n```rust\nassert_eq!(1.0 < 1.0, false);\nassert_eq!(1.0 < 2.0, true);\nassert_eq!(2.0 < 1.0, false);\n```"
      },
      "sortText": "80000009",
      "filterText": "lt",
      "textEdit": {
        "range": {
          "start": {
            "line": 20,
            "character": 8
          },
          "end": {
            "line": 20,
            "character": 12
          }
        },
        "newText": "lt"
      }
    },
    {
      "label": "le(as PartialOrd)",
      "kind": 2,
      "detail": "pub fn le(&self, other: &Rhs) -> bool",
      "documentation": {
        "kind": "markdown",
        "value": "Tests less than or equal to (for `self` and `other`) and is used by the\n`<=` operator.\n\n# Examples\n\n```rust\nassert_eq!(1.0 <= 1.0, true);\nassert_eq!(1.0 <= 2.0, true);\nassert_eq!(2.0 <= 1.0, false);\n```"
      },
      "sortText": "80000009",
      "filterText": "le",
      "textEdit": {
        "range": {
          "start": {
            "line": 20,
            "character": 8
          },
          "end": {
            "line": 20,
            "character": 12
          }
        },
        "newText": "le"
      }
    },
    {
      "label": "gt(as PartialOrd)",
      "kind": 2,
      "detail": "pub fn gt(&self, other: &Rhs) -> bool",
      "documentation": {
        "kind": "markdown",
        "value": "Tests greater than (for `self` and `other`) and is used by the `>`\noperator.\n\n# Examples\n\n```rust\nassert_eq!(1.0 > 1.0, false);\nassert_eq!(1.0 > 2.0, false);\nassert_eq!(2.0 > 1.0, true);\n```"
      },
      "sortText": "80000009",
      "filterText": "gt",
      "textEdit": {
        "range": {
          "start": {
            "line": 20,
            "character": 8
          },
          "end": {
            "line": 20,
            "character": 12
          }
        },
        "newText": "gt"
      }
    },
    {
      "label": "ge(as PartialOrd)",
      "kind": 2,
      "detail": "pub fn ge(&self, other: &Rhs) -> bool",
      "documentation": {
        "kind": "markdown",
        "value": "Tests greater than or equal to (for `self` and `other`) and is used by\nthe `>=` operator.\n\n# Examples\n\n```rust\nassert_eq!(1.0 >= 1.0, true);\nassert_eq!(1.0 >= 2.0, false);\nassert_eq!(2.0 >= 1.0, true);\n```"
      },
      "sortText": "80000009",
      "filterText": "ge",
      "textEdit": {
        "range": {
          "start": {
            "line": 20,
            "character": 8
          },
          "end": {
            "line": 20,
            "character": 12
          }
        },
        "newText": "ge"
      }
    },
    {
      "label": "as_ref(as AsRef)",
      "kind": 2,
      "detail": "pub fn as_ref(&self) -> &T",
      "documentation": {
        "kind": "markdown",
        "value": "Converts this type into a shared reference of the (usually inferred) input type."
      },
      "sortText": "80000004",
      "filterText": "as_ref",
      "textEdit": {
        "range": {
          "start": {
            "line": 20,
            "character": 8
          },
          "end": {
            "line": 20,
            "character": 12
          }
        },
        "newText": "as_ref"
      }
    },
    {
      "label": "clone(as Clone)",
      "kind": 2,
      "detail": "pub fn clone(&self) -> Self",
      "documentation": {
        "kind": "markdown",
        "value": "Returns a duplicate of the value.\n\nNote that what \"duplicate\" means varies by type:\n- For most types, this creates a deep, independent copy\n- For reference types like `&T`, this creates another reference to the same value\n- For smart pointers like [`Arc`] or [`Rc`], this increments the reference count\n  but still points to the same underlying data\n\n[`Arc`]: ../../std/sync/struct.Arc.html\n[`Rc`]: ../../std/rc/struct.Rc.html\n\n# Examples\n\n```rust\nlet hello = \"Hello\"; // &str implements Clone\n\nassert_eq!(\"Hello\", hello.clone());\n```\n\nExample with a reference-counted type:\n\n```rust\nuse std::sync::{Arc, Mutex};\n\nlet data = Arc::new(Mutex::new(vec![1, 2, 3]));\nlet data_clone = data.clone(); // Creates another Arc pointing to the same Mutex\n\n{\n    let mut lock = data.lock().unwrap();\n    lock.push(4);\n}\n\n// Changes are visible through the clone because they share the same underlying data\nassert_eq!(*data_clone.lock().unwrap(), vec![1, 2, 3, 4]);\n```"
      },
      "sortText": "80000004",
      "filterText": "clone",
      "textEdit": {
        "range": {
          "start": {
            "line": 20,
            "character": 8
          },
          "end": {
            "line": 20,
            "character": 12
          }
        },
        "newText": "clone"
      }
    },
    {
      "label": "clone_from(as Clone)",
      "kind": 2,
      "detail": "pub fn clone_from(&mut self, source: &Self) where Self: Destruct,",
      "documentation": {
        "kind": "markdown",
        "value": "Performs copy-assignment from `source`.\n\n`a.clone_from(&b)` is equivalent to `a = b.clone()` in functionality,\nbut can be overridden to reuse the resources of `a` to avoid unnecessary\nallocations."
      },
      "sortText": "80000004",
      "filterText": "clone_from",
      "textEdit": {
        "range": {
          "start": {
            "line": 20,
            "character": 8
          },
          "end": {
            "line": 20,
            "character": 12
          }
        },
        "newText": "clone_from"
      }
    },
    {
      "label": "from(as From)",
      "kind": 3,
      "detail": "pub fn from(value: T) -> Self",
      "documentation": {
        "kind": "markdown",
        "value": "Converts to this type from the input type."
      },
      "sortText": "80000004",
      "filterText": "from",
      "textEdit": {
        "range": {
          "start": {
            "line": 20,
            "character": 8
          },
          "end": {
            "line": 20,
            "character": 12
          }
        },
        "newText": "from"
      }
    },
    {
      "label": "default(as Default)",
      "kind": 3,
      "detail": "pub fn default() -> Self",
      "documentation": {
        "kind": "markdown",
        "value": "Returns the \"default value\" for a type.\n\nDefault values are often some kind of initial value, identity value, or anything else that\nmay make sense as a default.\n\n# Examples\n\nUsing built-in default values:\n\n```rust\nlet i: i8 = Default::default();\nlet (x, y): (Option<String>, f64) = Default::default();\nlet (a, b, (c, d)): (i32, u32, (bool, bool)) = Default::default();\n```\n\nMaking your own:\n\n```rust\nenum Kind {\n    A,\n    B,\n    C,\n}\n\nimpl Default for Kind {\n    fn default() -> Self { Kind::A }\n}\n```"
      },
      "sortText": "80000004",
      "filterText": "default",
      "textEdit": {
        "range": {
          "start": {
            "line": 20,
            "character": 8
          },
          "end": {
            "line": 20,
            "character": 12
          }
        },
        "newText": "default"
      }
    },
    {
      "label": "cmp(as Ord)",
      "kind": 2,
      "detail": "pub fn cmp(&self, other: &Self) -> Ordering",
      "documentation": {
        "kind": "markdown",
        "value": "This method returns an [`Ordering`] between `self` and `other`.\n\nBy convention, `self.cmp(&other)` returns the ordering matching the expression\n`self <operator> other` if true.\n\n# Examples\n\n```rust\nuse std::cmp::Ordering;\n\nassert_eq!(5.cmp(&10), Ordering::Less);\nassert_eq!(10.cmp(&5), Ordering::Greater);\nassert_eq!(5.cmp(&5), Ordering::Equal);\n```"
      },
      "sortText": "80000004",
      "filterText": "cmp",
      "textEdit": {
        "range": {
          "start": {
            "line": 20,
            "character": 8
          },
          "end": {
            "line": 20,
            "character": 12
          }
        },
        "newText": "cmp"
      }
    },
    {
      "label": "max(as Ord)",
      "kind": 2,
      "detail": "pub fn max(self, other: Self) -> Self where Self: Sized + Destruct,",
      "documentation": {
        "kind": "markdown",
        "value": "Compares and returns the maximum of two values.\n\nReturns the second argument if the comparison determines them to be equal.\n\n# Examples\n\n```rust\nassert_eq!(1.max(2), 2);\nassert_eq!(2.max(2), 2);\n```\n```rust\nuse std::cmp::Ordering;\n\n#[derive(Eq)]\nstruct Equal(&'static str);\n\nimpl PartialEq for Equal {\n    fn eq(&self, other: &Self) -> bool { true }\n}\nimpl PartialOrd for Equal {\n    fn partial_cmp(&self, other: &Self) -> Option<Ordering> { Some(Ordering::Equal) }\n}\nimpl Ord for Equal {\n    fn cmp(&self, other: &Self) -> Ordering { Ordering::Equal }\n}\n\nassert_eq!(Equal(\"self\").max(Equal(\"other\")).0, \"other\");\n```"
      },
      "sortText": "80000004",
      "filterText": "max",
      "textEdit": {
        "range": {
          "start": {
            "line": 20,
            "character": 8
          },
          "end": {
            "line": 20,
            "character": 12
          }
        },
        "newText": "max"
      }
    },
    {
      "label": "min(as Ord)",
      "kind": 2,
      "detail": "pub fn min(self, other: Self) -> Self where Self: Sized + Destruct,",
      "documentation": {
        "kind": "markdown",
        "value": "Compares and returns the minimum of two values.\n\nReturns the first argument if the comparison determines them to be equal.\n\n# Examples\n\n```rust\nassert_eq!(1.min(2), 1);\nassert_eq!(2.min(2), 2);\n```\n```rust\nuse std::cmp::Ordering;\n\n#[derive(Eq)]\nstruct Equal(&'static str);\n\nimpl PartialEq for Equal {\n    fn eq(&self, other: &Self) -> bool { true }\n}\nimpl PartialOrd for Equal {\n    fn partial_cmp(&self, other: &Self) -> Option<Ordering> { Some(Ordering::Equal) }\n}\nimpl Ord for Equal {\n    fn cmp(&self, other: &Self) -> Ordering { Ordering::Equal }\n}\n\nassert_eq!(Equal(\"self\").min(Equal(\"other\")).0, \"self\");\n```"
      },
      "sortText": "80000004",
      "filterText": "min",
      "textEdit": {
        "range": {
          "start": {
            "line": 20,
            "character": 8
          },
          "end": {
            "line": 20,
            "character": 12
          }
        },
        "newText": "min"
      }
    },
    {
      "label": "clamp(as Ord)",
      "kind": 2,
      "detail": "pub fn clamp(self, min: Self, max: Self) -> Self where Self: Sized + Destruct,",
      "documentation": {
        "kind": "markdown",
        "value": "Restrict a value to a certain interval.\n\nReturns `max` if `self` is greater than `max`, and `min` if `self` is\nless than `min`. Otherwise this returns `self`.\n\n# Panics\n\nPanics if `min > max`.\n\n# Examples\n\n```rust\nassert_eq!((-3).clamp(-2, 1), -2);\nassert_eq!(0.clamp(-2, 1), 0);\nassert_eq!(2.clamp(-2, 1), 1);\n```"
      },
      "sortText": "80000004",
      "filterText": "clamp",
      "textEdit": {
        "range": {
          "start": {
            "line": 20,
            "character": 8
          },
          "end": {
            "line": 20,
            "character": 12
          }
        },
        "newText": "clamp"
      }
    }
  ]
}