@enjoys/context-engine 1.3.1 → 1.4.2

package/data/definition/rust.json

@@ -1,207 +1,853 @@
-{
-  "language": "rust",
-  "definitions": {
-    "String": {
-      "signature": "pub struct String",
-      "description": "A UTF-8–encoded, growable string. The most common string type in Rust, owning its contents.",
-      "type": "struct",
-      "module": "std::string",
-      "members": {
-        "new": { "signature": "pub const fn new() -> String", "description": "Creates a new empty `String`.", "type": "method" },
-        "from": { "signature": "pub fn from(s: &str) -> String", "description": "Converts a `&str` into a `String`.", "type": "method" },
-        "push": { "signature": "pub fn push(&mut self, ch: char)", "description": "Appends the given `char` to the end of this `String`.", "type": "method" },
-        "push_str": { "signature": "pub fn push_str(&mut self, string: &str)", "description": "Appends a given string slice onto the end of this `String`.", "type": "method" },
-        "len": { "signature": "pub fn len(&self) -> usize", "description": "Returns the length of this `String`, in bytes, not `char`s or graphemes.", "type": "method" },
-        "is_empty": { "signature": "pub fn is_empty(&self) -> bool", "description": "Returns `true` if this `String` has a length of zero.", "type": "method" },
-        "capacity": { "signature": "pub fn capacity(&self) -> usize", "description": "Returns this `String`'s capacity, in bytes.", "type": "method" },
-        "contains": { "signature": "pub fn contains<'a, P: Pattern<'a>>(&'a self, pat: P) -> bool", "description": "Returns `true` if the given pattern matches a sub-slice of this string slice.", "type": "method" },
-        "replace": { "signature": "pub fn replace<'a, P: Pattern<'a>>(&'a self, from: P, to: &str) -> String", "description": "Replaces all matches of a pattern with another string.", "type": "method" },
-        "trim": { "signature": "pub fn trim(&self) -> &str", "description": "Returns a string slice with leading and trailing whitespace removed.", "type": "method" },
-        "to_uppercase": { "signature": "pub fn to_uppercase(&self) -> String", "description": "Returns the uppercase equivalent of this string slice, as a new `String`.", "type": "method" },
-        "to_lowercase": { "signature": "pub fn to_lowercase(&self) -> String", "description": "Returns the lowercase equivalent of this string slice, as a new `String`.", "type": "method" },
-        "as_str": { "signature": "pub fn as_str(&self) -> &str", "description": "Extracts a string slice containing the entire `String`.", "type": "method" },
-        "as_bytes": { "signature": "pub fn as_bytes(&self) -> &[u8]", "description": "Returns a byte slice of this `String`'s contents.", "type": "method" },
-        "chars": { "signature": "pub fn chars(&self) -> Chars<'_>", "description": "Returns an iterator over the `char`s of this string slice.", "type": "method" },
-        "split": { "signature": "pub fn split<'a, P: Pattern<'a>>(&'a self, pat: P) -> Split<'a, P>", "description": "Returns an iterator over substrings of this string slice, separated by a pattern.", "type": "method" },
-        "starts_with": { "signature": "pub fn starts_with<'a, P: Pattern<'a>>(&'a self, pat: P) -> bool", "description": "Returns `true` if the given pattern matches a prefix of this string slice.", "type": "method" },
-        "ends_with": { "signature": "pub fn ends_with<'a, P: Pattern<'a>>(&'a self, pat: P) -> bool", "description": "Returns `true` if the given pattern matches a suffix of this string slice.", "type": "method" },
-        "into_bytes": { "signature": "pub fn into_bytes(self) -> Vec<u8>", "description": "Converts this `String` into a byte vector, consuming the string.", "type": "method" }
-      }
-    },
-    "Vec": {
-      "signature": "pub struct Vec<T>",
-      "description": "A contiguous growable array type. Provides O(1) indexed access, amortized O(1) push to the end, and O(n) insert and removal.",
-      "type": "struct",
-      "module": "std::vec",
-      "members": {
-        "new": { "signature": "pub const fn new() -> Vec<T>", "description": "Constructs a new, empty `Vec<T>`. Does not allocate until elements are pushed.", "type": "method" },
-        "with_capacity": { "signature": "pub fn with_capacity(capacity: usize) -> Vec<T>", "description": "Constructs a new, empty `Vec<T>` with at least the specified capacity.", "type": "method" },
-        "push": { "signature": "pub fn push(&mut self, value: T)", "description": "Appends an element to the back of the collection.", "type": "method" },
-        "pop": { "signature": "pub fn pop(&mut self) -> Option<T>", "description": "Removes the last element from the vector and returns it, or `None` if empty.", "type": "method" },
-        "len": { "signature": "pub fn len(&self) -> usize", "description": "Returns the number of elements in the vector.", "type": "method" },
-        "is_empty": { "signature": "pub fn is_empty(&self) -> bool", "description": "Returns `true` if the vector contains no elements.", "type": "method" },
-        "contains": { "signature": "pub fn contains(&self, x: &T) -> bool where T: PartialEq", "description": "Returns `true` if the slice contains an element with the given value.", "type": "method" },
-        "iter": { "signature": "pub fn iter(&self) -> Iter<'_, T>", "description": "Returns an iterator over the slice.", "type": "method" },
-        "iter_mut": { "signature": "pub fn iter_mut(&mut self) -> IterMut<'_, T>", "description": "Returns a mutable iterator over the slice.", "type": "method" },
-        "sort": { "signature": "pub fn sort(&mut self) where T: Ord", "description": "Sorts the slice in ascending order. This sort is stable (preserves order of equal elements).", "type": "method" },
-        "sort_by": { "signature": "pub fn sort_by<F>(&mut self, compare: F) where F: FnMut(&T, &T) -> Ordering", "description": "Sorts the slice with a comparator function. Stable sort.", "type": "method" },
-        "retain": { "signature": "pub fn retain<F>(&mut self, f: F) where F: FnMut(&T) -> bool", "description": "Retains only the elements specified by the predicate.", "type": "method" },
-        "extend": { "signature": "pub fn extend<I: IntoIterator<Item = T>>(&mut self, iter: I)", "description": "Extends the collection with the contents of an iterator.", "type": "method" },
-        "drain": { "signature": "pub fn drain<R: RangeBounds<usize>>(&mut self, range: R) -> Drain<'_, T>", "description": "Removes the specified range from the vector in bulk, returning an iterator over the removed items.", "type": "method" },
-        "truncate": { "signature": "pub fn truncate(&mut self, len: usize)", "description": "Shortens the vector, keeping the first `len` elements and dropping the rest.", "type": "method" },
-        "clear": { "signature": "pub fn clear(&mut self)", "description": "Clears the vector, removing all values. Does not affect allocated capacity.", "type": "method" },
-        "get": { "signature": "pub fn get<I: SliceIndex<[T]>>(&self, index: I) -> Option<&I::Output>", "description": "Returns a reference to an element or subslice, or `None` if out of bounds.", "type": "method" },
-        "first": { "signature": "pub fn first(&self) -> Option<&T>", "description": "Returns the first element of the slice, or `None` if empty.", "type": "method" },
-        "last": { "signature": "pub fn last(&self) -> Option<&T>", "description": "Returns the last element of the slice, or `None` if empty.", "type": "method" },
-        "remove": { "signature": "pub fn remove(&mut self, index: usize) -> T", "description": "Removes and returns the element at position `index`, shifting all elements after it to the left.", "type": "method" },
-        "insert": { "signature": "pub fn insert(&mut self, index: usize, element: T)", "description": "Inserts an element at position `index`, shifting all elements after it to the right.", "type": "method" },
-        "swap_remove": { "signature": "pub fn swap_remove(&mut self, index: usize) -> T", "description": "Removes an element from the vector and returns it, replacing it with the last element. O(1) but does not preserve ordering.", "type": "method" },
-        "dedup": { "signature": "pub fn dedup(&mut self) where T: PartialEq", "description": "Removes consecutive repeated elements. If the vector is sorted, this removes all duplicates.", "type": "method" },
-        "binary_search": { "signature": "pub fn binary_search(&self, x: &T) -> Result<usize, usize> where T: Ord", "description": "Binary searches for a given element. If found, returns `Ok(index)`. If not found, returns `Err(index)` where the element could be inserted.", "type": "method" },
-        "windows": { "signature": "pub fn windows(&self, size: usize) -> Windows<'_, T>", "description": "Returns an iterator over overlapping sub-slices of the given size.", "type": "method" },
-        "chunks": { "signature": "pub fn chunks(&self, chunk_size: usize) -> Chunks<'_, T>", "description": "Returns an iterator over `chunk_size` elements of the slice at a time.", "type": "method" }
-      }
-    },
-    "HashMap": {
-      "signature": "pub struct HashMap<K, V, S = RandomState>",
-      "description": "A hash map implemented with quadratic probing and SIMD lookup. Requires keys to implement Eq and Hash.",
-      "type": "struct",
-      "module": "std::collections",
-      "members": {
-        "new": { "signature": "pub fn new() -> HashMap<K, V>", "description": "Creates an empty `HashMap`.", "type": "method" },
-        "insert": { "signature": "pub fn insert(&mut self, k: K, v: V) -> Option<V>", "description": "Inserts a key-value pair. If the key existed, the old value is returned.", "type": "method" },
-        "get": { "signature": "pub fn get<Q: ?Sized>(&self, k: &Q) -> Option<&V> where K: Borrow<Q>, Q: Hash + Eq", "description": "Returns a reference to the value corresponding to the key.", "type": "method" },
-        "get_mut": { "signature": "pub fn get_mut<Q: ?Sized>(&mut self, k: &Q) -> Option<&mut V> where K: Borrow<Q>, Q: Hash + Eq", "description": "Returns a mutable reference to the value corresponding to the key.", "type": "method" },
-        "remove": { "signature": "pub fn remove<Q: ?Sized>(&mut self, k: &Q) -> Option<V> where K: Borrow<Q>, Q: Hash + Eq", "description": "Removes a key from the map, returning the value if the key was present.", "type": "method" },
-        "contains_key": { "signature": "pub fn contains_key<Q: ?Sized>(&self, k: &Q) -> bool where K: Borrow<Q>, Q: Hash + Eq", "description": "Returns `true` if the map contains a value for the specified key.", "type": "method" },
-        "keys": { "signature": "pub fn keys(&self) -> Keys<'_, K, V>", "description": "Returns an iterator visiting all keys in arbitrary order.", "type": "method" },
-        "values": { "signature": "pub fn values(&self) -> Values<'_, K, V>", "description": "Returns an iterator visiting all values in arbitrary order.", "type": "method" },
-        "iter": { "signature": "pub fn iter(&self) -> Iter<'_, K, V>", "description": "Returns an iterator visiting all key-value pairs in arbitrary order.", "type": "method" },
-        "len": { "signature": "pub fn len(&self) -> usize", "description": "Returns the number of elements in the map.", "type": "method" },
-        "is_empty": { "signature": "pub fn is_empty(&self) -> bool", "description": "Returns `true` if the map contains no elements.", "type": "method" },
-        "entry": { "signature": "pub fn entry(&mut self, key: K) -> Entry<'_, K, V>", "description": "Gets the given key's corresponding entry in the map for in-place manipulation.", "type": "method" },
-        "extend": { "signature": "pub fn extend<I: IntoIterator<Item = (K, V)>>(&mut self, iter: I)", "description": "Extends the map with the contents of an iterator of key-value pairs.", "type": "method" },
-        "drain": { "signature": "pub fn drain(&mut self) -> Drain<'_, K, V>", "description": "Clears the map, returning all key-value pairs as an iterator.", "type": "method" },
-        "retain": { "signature": "pub fn retain<F>(&mut self, f: F) where F: FnMut(&K, &mut V) -> bool", "description": "Retains only the elements specified by the predicate.", "type": "method" }
-      }
-    },
-    "Option": {
-      "signature": "pub enum Option<T> { None, Some(T) }",
-      "description": "Represents an optional value. Every Option is either Some containing a value, or None.",
-      "type": "enum",
-      "module": "std::option",
-      "members": {
-        "Some": { "signature": "Some(T)", "description": "Contains the success value.", "type": "variant" },
-        "None": { "signature": "None", "description": "No value.", "type": "variant" },
-        "unwrap": { "signature": "pub fn unwrap(self) -> T", "description": "Returns the contained `Some` value. Panics if the value is `None`.", "type": "method" },
-        "unwrap_or": { "signature": "pub fn unwrap_or(self, default: T) -> T", "description": "Returns the contained `Some` value or a provided default.", "type": "method" },
-        "unwrap_or_else": { "signature": "pub fn unwrap_or_else<F: FnOnce() -> T>(self, f: F) -> T", "description": "Returns the contained `Some` value or computes it from a closure.", "type": "method" },
-        "unwrap_or_default": { "signature": "pub fn unwrap_or_default(self) -> T where T: Default", "description": "Returns the contained `Some` value or the default value of `T`.", "type": "method" },
-        "map": { "signature": "pub fn map<U, F: FnOnce(T) -> U>(self, f: F) -> Option<U>", "description": "Maps an `Option<T>` to `Option<U>` by applying a function to the contained value.", "type": "method" },
-        "and_then": { "signature": "pub fn and_then<U, F: FnOnce(T) -> Option<U>>(self, f: F) -> Option<U>", "description": "Returns `None` if the option is `None`, otherwise calls `f` with the wrapped value and returns the result. Also known as flat_map.", "type": "method" },
-        "or": { "signature": "pub fn or(self, optb: Option<T>) -> Option<T>", "description": "Returns the option if it contains a value, otherwise returns `optb`.", "type": "method" },
-        "or_else": { "signature": "pub fn or_else<F: FnOnce() -> Option<T>>(self, f: F) -> Option<T>", "description": "Returns the option if it contains a value, otherwise calls `f` and returns the result.", "type": "method" },
-        "filter": { "signature": "pub fn filter<P: FnOnce(&T) -> bool>(self, predicate: P) -> Option<T>", "description": "Returns `None` if the option is `None`, otherwise calls `predicate` and returns `Some(t)` if the predicate returns `true`.", "type": "method" },
-        "is_some": { "signature": "pub fn is_some(&self) -> bool", "description": "Returns `true` if the option is a `Some` value.", "type": "method" },
-        "is_none": { "signature": "pub fn is_none(&self) -> bool", "description": "Returns `true` if the option is a `None` value.", "type": "method" },
-        "ok_or": { "signature": "pub fn ok_or<E>(self, err: E) -> Result<T, E>", "description": "Transforms the `Option<T>` into a `Result<T, E>`, mapping `Some(v)` to `Ok(v)` and `None` to `Err(err)`.", "type": "method" },
-        "flatten": { "signature": "pub fn flatten(self) -> Option<T> where T: Option<T>", "description": "Converts from `Option<Option<T>>` to `Option<T>`.", "type": "method" },
-        "zip": { "signature": "pub fn zip<U>(self, other: Option<U>) -> Option<(T, U)>", "description": "Zips `self` with another `Option`. Returns `Some((a, b))` if both are `Some`, otherwise `None`.", "type": "method" },
-        "take": { "signature": "pub fn take(&mut self) -> Option<T>", "description": "Takes the value out of the option, leaving a `None` in its place.", "type": "method" }
-      }
-    },
-    "Result": {
-      "signature": "pub enum Result<T, E> { Ok(T), Err(E) }",
-      "description": "A type used for returning and propagating errors. Ok(T) represents success, Err(E) represents failure.",
-      "type": "enum",
-      "module": "std::result",
-      "members": {
-        "Ok": { "signature": "Ok(T)", "description": "Contains the success value.", "type": "variant" },
-        "Err": { "signature": "Err(E)", "description": "Contains the error value.", "type": "variant" },
-        "unwrap": { "signature": "pub fn unwrap(self) -> T where E: Debug", "description": "Returns the contained `Ok` value. Panics if the value is an `Err`, with a panic message from the error's `Debug` impl.", "type": "method" },
-        "unwrap_or": { "signature": "pub fn unwrap_or(self, default: T) -> T", "description": "Returns the contained `Ok` value or a provided default.", "type": "method" },
-        "unwrap_err": { "signature": "pub fn unwrap_err(self) -> E where T: Debug", "description": "Returns the contained `Err` value. Panics if the value is `Ok`.", "type": "method" },
-        "map": { "signature": "pub fn map<U, F: FnOnce(T) -> U>(self, op: F) -> Result<U, E>", "description": "Maps a `Result<T, E>` to `Result<U, E>` by applying a function to a contained `Ok` value.", "type": "method" },
-        "map_err": { "signature": "pub fn map_err<F, O: FnOnce(E) -> F>(self, op: O) -> Result<T, F>", "description": "Maps a `Result<T, E>` to `Result<T, F>` by applying a function to a contained `Err` value.", "type": "method" },
-        "and_then": { "signature": "pub fn and_then<U, F: FnOnce(T) -> Result<U, E>>(self, op: F) -> Result<U, E>", "description": "Calls `op` if the result is `Ok`, otherwise returns the `Err` value of self.", "type": "method" },
-        "or": { "signature": "pub fn or<F>(self, res: Result<T, F>) -> Result<T, F>", "description": "Returns `res` if the result is `Err`, otherwise returns the `Ok` value of self.", "type": "method" },
-        "or_else": { "signature": "pub fn or_else<F, O: FnOnce(E) -> Result<T, F>>(self, op: O) -> Result<T, F>", "description": "Calls `op` if the result is `Err`, otherwise returns the `Ok` value of self.", "type": "method" },
-        "is_ok": { "signature": "pub fn is_ok(&self) -> bool", "description": "Returns `true` if the result is `Ok`.", "type": "method" },
-        "is_err": { "signature": "pub fn is_err(&self) -> bool", "description": "Returns `true` if the result is `Err`.", "type": "method" },
-        "ok": { "signature": "pub fn ok(self) -> Option<T>", "description": "Converts from `Result<T, E>` to `Option<T>`, discarding the error.", "type": "method" },
-        "err": { "signature": "pub fn err(self) -> Option<E>", "description": "Converts from `Result<T, E>` to `Option<E>`, discarding the success value.", "type": "method" },
-        "expect": { "signature": "pub fn expect(self, msg: &str) -> T where E: Debug", "description": "Returns the contained `Ok` value. Panics with the provided message if `Err`.", "type": "method" }
-      }
-    },
-    "Box": {
-      "signature": "pub struct Box<T: ?Sized>",
-      "description": "A pointer type for heap allocation. Box<T> provides ownership of a heap-allocated value of type T.",
-      "type": "struct",
-      "module": "std::boxed",
-      "members": {
-        "new": { "signature": "pub fn new(x: T) -> Box<T>", "description": "Allocates memory on the heap and places `x` into it.", "type": "method" },
-        "into_raw": { "signature": "pub fn into_raw(b: Box<T>) -> *mut T", "description": "Consumes the `Box`, returning a raw pointer. The caller is responsible for freeing the memory.", "type": "method" },
-        "from_raw": { "signature": "pub unsafe fn from_raw(raw: *mut T) -> Box<T>", "description": "Constructs a `Box<T>` from a raw pointer. Undefined behavior if the pointer was not allocated by `Box`.", "type": "method" },
-        "leak": { "signature": "pub fn leak<'a>(b: Box<T>) -> &'a mut T", "description": "Consumes and leaks the `Box`, returning a mutable reference with a `'static` lifetime.", "type": "method" }
-      }
-    },
-    "Rc": {
-      "signature": "pub struct Rc<T: ?Sized>",
-      "description": "A single-threaded reference-counting pointer. Rc provides shared ownership of a value of type T, allocated on the heap.",
-      "type": "struct",
-      "module": "std::rc",
-      "members": {
-        "new": { "signature": "pub fn new(value: T) -> Rc<T>", "description": "Constructs a new `Rc<T>`.", "type": "method" },
-        "clone": { "signature": "pub fn clone(this: &Rc<T>) -> Rc<T>", "description": "Creates a new pointer to the same allocation, incrementing the reference count.", "type": "method" },
-        "strong_count": { "signature": "pub fn strong_count(this: &Rc<T>) -> usize", "description": "Gets the number of strong (`Rc`) pointers to this allocation.", "type": "method" },
-        "try_unwrap": { "signature": "pub fn try_unwrap(this: Rc<T>) -> Result<T, Rc<T>>", "description": "Returns the inner value if the `Rc` has exactly one strong reference.", "type": "method" },
-        "downgrade": { "signature": "pub fn downgrade(this: &Rc<T>) -> Weak<T>", "description": "Creates a new `Weak` pointer to this allocation.", "type": "method" }
-      }
-    },
-    "Arc": {
-      "signature": "pub struct Arc<T: ?Sized>",
-      "description": "A thread-safe reference-counting pointer. Arc stands for Atomically Reference Counted.",
-      "type": "struct",
-      "module": "std::sync",
-      "members": {
-        "new": { "signature": "pub fn new(data: T) -> Arc<T>", "description": "Constructs a new `Arc<T>`.", "type": "method" },
-        "clone": { "signature": "pub fn clone(this: &Arc<T>) -> Arc<T>", "description": "Creates a new pointer to the same allocation, atomically incrementing the reference count.", "type": "method" },
-        "strong_count": { "signature": "pub fn strong_count(this: &Arc<T>) -> usize", "description": "Gets the number of strong (`Arc`) pointers to this allocation.", "type": "method" },
-        "try_unwrap": { "signature": "pub fn try_unwrap(this: Arc<T>) -> Result<T, Arc<T>>", "description": "Returns the inner value if the `Arc` has exactly one strong reference.", "type": "method" },
-        "downgrade": { "signature": "pub fn downgrade(this: &Arc<T>) -> Weak<T>", "description": "Creates a new `Weak` pointer to this allocation.", "type": "method" }
-      }
-    },
-    "Iterator": {
-      "signature": "pub trait Iterator",
-      "description": "A trait for dealing with iterators. Only the next method is required; all other methods have default implementations.",
-      "type": "trait",
-      "module": "std::iter",
-      "members": {
-        "next": { "signature": "fn next(&mut self) -> Option<Self::Item>", "description": "Advances the iterator and returns the next value. Returns `None` when iteration is complete.", "type": "method" },
-        "map": { "signature": "fn map<B, F: FnMut(Self::Item) -> B>(self, f: F) -> Map<Self, F>", "description": "Takes a closure and creates an iterator that calls that closure on each element.", "type": "method" },
-        "filter": { "signature": "fn filter<P: FnMut(&Self::Item) -> bool>(self, predicate: P) -> Filter<Self, P>", "description": "Creates an iterator that only yields elements matching the predicate.", "type": "method" },
-        "fold": { "signature": "fn fold<B, F: FnMut(B, Self::Item) -> B>(self, init: B, f: F) -> B", "description": "Folds every element into an accumulator by applying a closure, returning the final result.", "type": "method" },
-        "collect": { "signature": "fn collect<B: FromIterator<Self::Item>>(self) -> B", "description": "Transforms an iterator into a collection. Can collect into Vec, HashMap, String, etc.", "type": "method" },
-        "enumerate": { "signature": "fn enumerate(self) -> Enumerate<Self>", "description": "Creates an iterator that yields `(index, value)` pairs.", "type": "method" },
-        "zip": { "signature": "fn zip<U: IntoIterator>(self, other: U) -> Zip<Self, U::IntoIter>", "description": "Zips two iterators into a single iterator of pairs.", "type": "method" },
-        "take": { "signature": "fn take(self, n: usize) -> Take<Self>", "description": "Creates an iterator that yields at most `n` elements.", "type": "method" },
-        "skip": { "signature": "fn skip(self, n: usize) -> Skip<Self>", "description": "Creates an iterator that skips the first `n` elements.", "type": "method" },
-        "chain": { "signature": "fn chain<U: IntoIterator<Item = Self::Item>>(self, other: U) -> Chain<Self, U::IntoIter>", "description": "Creates an iterator that chains two iterators together, yielding elements from the first then the second.", "type": "method" },
-        "flatten": { "signature": "fn flatten(self) -> Flatten<Self> where Self::Item: IntoIterator", "description": "Creates an iterator that flattens nested structure.", "type": "method" },
-        "any": { "signature": "fn any<F: FnMut(Self::Item) -> bool>(&mut self, f: F) -> bool", "description": "Tests if any element of the iterator matches a predicate.", "type": "method" },
-        "all": { "signature": "fn all<F: FnMut(Self::Item) -> bool>(&mut self, f: F) -> bool", "description": "Tests if every element of the iterator matches a predicate.", "type": "method" },
-        "find": { "signature": "fn find<P: FnMut(&Self::Item) -> bool>(&mut self, predicate: P) -> Option<Self::Item>", "description": "Searches for an element that satisfies the predicate.", "type": "method" },
-        "position": { "signature": "fn position<P: FnMut(Self::Item) -> bool>(&mut self, predicate: P) -> Option<usize>", "description": "Searches for an element, returning its index.", "type": "method" },
-        "count": { "signature": "fn count(self) -> usize", "description": "Consumes the iterator, counting the number of elements.", "type": "method" },
-        "sum": { "signature": "fn sum<S: Sum<Self::Item>>(self) -> S", "description": "Sums the elements of an iterator.", "type": "method" },
-        "product": { "signature": "fn product<P: Product<Self::Item>>(self) -> P", "description": "Iterates over the entire iterator, multiplying all elements.", "type": "method" },
-        "min": { "signature": "fn min(self) -> Option<Self::Item> where Self::Item: Ord", "description": "Returns the minimum element of an iterator.", "type": "method" },
-        "max": { "signature": "fn max(self) -> Option<Self::Item> where Self::Item: Ord", "description": "Returns the maximum element of an iterator.", "type": "method" },
-        "cloned": { "signature": "fn cloned<'a, T: 'a + Clone>(self) -> Cloned<Self> where Self: Iterator<Item = &'a T>", "description": "Creates an iterator that clones all of its elements.", "type": "method" },
-        "copied": { "signature": "fn copied<'a, T: 'a + Copy>(self) -> Copied<Self> where Self: Iterator<Item = &'a T>", "description": "Creates an iterator that copies all of its elements.", "type": "method" },
-        "peekable": { "signature": "fn peekable(self) -> Peekable<Self>", "description": "Creates an iterator that can use the `peek` method to look at the next element without consuming it.", "type": "method" },
-        "rev": { "signature": "fn rev(self) -> Rev<Self> where Self: DoubleEndedIterator", "description": "Reverses an iterator's direction.", "type": "method" }
-      }
-    }
-  }
+{
+  "language": "rust",
+  "definitions": {
+    "String": {
+      "signature": "pub struct String",
+      "description": "A UTF-8–encoded, growable string. The most common string type in Rust, owning its contents.",
+      "type": "struct",
+      "module": "std::string",
+      "members": {
+        "new": {
+          "signature": "pub const fn new() -> String",
+          "description": "Creates a new empty `String`.",
+          "type": "method"
+        },
+        "from": {
+          "signature": "pub fn from(s: &str) -> String",
+          "description": "Converts a `&str` into a `String`.",
+          "type": "method"
+        },
+        "push": {
+          "signature": "pub fn push(&mut self, ch: char)",
+          "description": "Appends the given `char` to the end of this `String`.",
+          "type": "method"
+        },
+        "push_str": {
+          "signature": "pub fn push_str(&mut self, string: &str)",
+          "description": "Appends a given string slice onto the end of this `String`.",
+          "type": "method"
+        },
+        "len": {
+          "signature": "pub fn len(&self) -> usize",
+          "description": "Returns the length of this `String`, in bytes, not `char`s or graphemes.",
+          "type": "method"
+        },
+        "is_empty": {
+          "signature": "pub fn is_empty(&self) -> bool",
+          "description": "Returns `true` if this `String` has a length of zero.",
+          "type": "method"
+        },
+        "capacity": {
+          "signature": "pub fn capacity(&self) -> usize",
+          "description": "Returns this `String`'s capacity, in bytes.",
+          "type": "method"
+        },
+        "contains": {
+          "signature": "pub fn contains<'a, P: Pattern<'a>>(&'a self, pat: P) -> bool",
+          "description": "Returns `true` if the given pattern matches a sub-slice of this string slice.",
+          "type": "method"
+        },
+        "replace": {
+          "signature": "pub fn replace<'a, P: Pattern<'a>>(&'a self, from: P, to: &str) -> String",
+          "description": "Replaces all matches of a pattern with another string.",
+          "type": "method"
+        },
+        "trim": {
+          "signature": "pub fn trim(&self) -> &str",
+          "description": "Returns a string slice with leading and trailing whitespace removed.",
+          "type": "method"
+        },
+        "to_uppercase": {
+          "signature": "pub fn to_uppercase(&self) -> String",
+          "description": "Returns the uppercase equivalent of this string slice, as a new `String`.",
+          "type": "method"
+        },
+        "to_lowercase": {
+          "signature": "pub fn to_lowercase(&self) -> String",
+          "description": "Returns the lowercase equivalent of this string slice, as a new `String`.",
+          "type": "method"
+        },
+        "as_str": {
+          "signature": "pub fn as_str(&self) -> &str",
+          "description": "Extracts a string slice containing the entire `String`.",
+          "type": "method"
+        },
+        "as_bytes": {
+          "signature": "pub fn as_bytes(&self) -> &[u8]",
+          "description": "Returns a byte slice of this `String`'s contents.",
+          "type": "method"
+        },
+        "chars": {
+          "signature": "pub fn chars(&self) -> Chars<'_>",
+          "description": "Returns an iterator over the `char`s of this string slice.",
+          "type": "method"
+        },
+        "split": {
+          "signature": "pub fn split<'a, P: Pattern<'a>>(&'a self, pat: P) -> Split<'a, P>",
+          "description": "Returns an iterator over substrings of this string slice, separated by a pattern.",
+          "type": "method"
+        },
+        "starts_with": {
+          "signature": "pub fn starts_with<'a, P: Pattern<'a>>(&'a self, pat: P) -> bool",
+          "description": "Returns `true` if the given pattern matches a prefix of this string slice.",
+          "type": "method"
+        },
+        "ends_with": {
+          "signature": "pub fn ends_with<'a, P: Pattern<'a>>(&'a self, pat: P) -> bool",
+          "description": "Returns `true` if the given pattern matches a suffix of this string slice.",
+          "type": "method"
+        },
+        "into_bytes": {
+          "signature": "pub fn into_bytes(self) -> Vec<u8>",
+          "description": "Converts this `String` into a byte vector, consuming the string.",
+          "type": "method"
+        }
+      }
+    },
+    "Vec": {
+      "signature": "pub struct Vec<T>",
+      "description": "A contiguous growable array type. Provides O(1) indexed access, amortized O(1) push to the end, and O(n) insert and removal.",
+      "type": "struct",
+      "module": "std::vec",
+      "members": {
+        "new": {
+          "signature": "pub const fn new() -> Vec<T>",
+          "description": "Constructs a new, empty `Vec<T>`. Does not allocate until elements are pushed.",
+          "type": "method"
+        },
+        "with_capacity": {
+          "signature": "pub fn with_capacity(capacity: usize) -> Vec<T>",
+          "description": "Constructs a new, empty `Vec<T>` with at least the specified capacity.",
+          "type": "method"
+        },
+        "push": {
+          "signature": "pub fn push(&mut self, value: T)",
+          "description": "Appends an element to the back of the collection.",
+          "type": "method"
+        },
+        "pop": {
+          "signature": "pub fn pop(&mut self) -> Option<T>",
+          "description": "Removes the last element from the vector and returns it, or `None` if empty.",
+          "type": "method"
+        },
+        "len": {
+          "signature": "pub fn len(&self) -> usize",
+          "description": "Returns the number of elements in the vector.",
+          "type": "method"
+        },
+        "is_empty": {
+          "signature": "pub fn is_empty(&self) -> bool",
+          "description": "Returns `true` if the vector contains no elements.",
+          "type": "method"
+        },
+        "contains": {
+          "signature": "pub fn contains(&self, x: &T) -> bool where T: PartialEq",
+          "description": "Returns `true` if the slice contains an element with the given value.",
+          "type": "method"
+        },
+        "iter": {
+          "signature": "pub fn iter(&self) -> Iter<'_, T>",
+          "description": "Returns an iterator over the slice.",
+          "type": "method"
+        },
+        "iter_mut": {
+          "signature": "pub fn iter_mut(&mut self) -> IterMut<'_, T>",
+          "description": "Returns a mutable iterator over the slice.",
+          "type": "method"
+        },
+        "sort": {
+          "signature": "pub fn sort(&mut self) where T: Ord",
+          "description": "Sorts the slice in ascending order. This sort is stable (preserves order of equal elements).",
+          "type": "method"
+        },
+        "sort_by": {
+          "signature": "pub fn sort_by<F>(&mut self, compare: F) where F: FnMut(&T, &T) -> Ordering",
+          "description": "Sorts the slice with a comparator function. Stable sort.",
+          "type": "method"
+        },
+        "retain": {
+          "signature": "pub fn retain<F>(&mut self, f: F) where F: FnMut(&T) -> bool",
+          "description": "Retains only the elements specified by the predicate.",
+          "type": "method"
+        },
+        "extend": {
+          "signature": "pub fn extend<I: IntoIterator<Item = T>>(&mut self, iter: I)",
+          "description": "Extends the collection with the contents of an iterator.",
+          "type": "method"
+        },
+        "drain": {
+          "signature": "pub fn drain<R: RangeBounds<usize>>(&mut self, range: R) -> Drain<'_, T>",
+          "description": "Removes the specified range from the vector in bulk, returning an iterator over the removed items.",
+          "type": "method"
+        },
+        "truncate": {
+          "signature": "pub fn truncate(&mut self, len: usize)",
+          "description": "Shortens the vector, keeping the first `len` elements and dropping the rest.",
+          "type": "method"
+        },
+        "clear": {
+          "signature": "pub fn clear(&mut self)",
+          "description": "Clears the vector, removing all values. Does not affect allocated capacity.",
+          "type": "method"
+        },
+        "get": {
+          "signature": "pub fn get<I: SliceIndex<[T]>>(&self, index: I) -> Option<&I::Output>",
+          "description": "Returns a reference to an element or subslice, or `None` if out of bounds.",
+          "type": "method"
+        },
+        "first": {
+          "signature": "pub fn first(&self) -> Option<&T>",
+          "description": "Returns the first element of the slice, or `None` if empty.",
+          "type": "method"
+        },
+        "last": {
+          "signature": "pub fn last(&self) -> Option<&T>",
+          "description": "Returns the last element of the slice, or `None` if empty.",
+          "type": "method"
+        },
+        "remove": {
+          "signature": "pub fn remove(&mut self, index: usize) -> T",
+          "description": "Removes and returns the element at position `index`, shifting all elements after it to the left.",
+          "type": "method"
+        },
+        "insert": {
+          "signature": "pub fn insert(&mut self, index: usize, element: T)",
+          "description": "Inserts an element at position `index`, shifting all elements after it to the right.",
+          "type": "method"
+        },
+        "swap_remove": {
+          "signature": "pub fn swap_remove(&mut self, index: usize) -> T",
+          "description": "Removes an element from the vector and returns it, replacing it with the last element. O(1) but does not preserve ordering.",
+          "type": "method"
+        },
+        "dedup": {
+          "signature": "pub fn dedup(&mut self) where T: PartialEq",
+          "description": "Removes consecutive repeated elements. If the vector is sorted, this removes all duplicates.",
+          "type": "method"
+        },
+        "binary_search": {
+          "signature": "pub fn binary_search(&self, x: &T) -> Result<usize, usize> where T: Ord",
+          "description": "Binary searches for a given element. If found, returns `Ok(index)`. If not found, returns `Err(index)` where the element could be inserted.",
+          "type": "method"
+        },
+        "windows": {
+          "signature": "pub fn windows(&self, size: usize) -> Windows<'_, T>",
+          "description": "Returns an iterator over overlapping sub-slices of the given size.",
+          "type": "method"
+        },
+        "chunks": {
+          "signature": "pub fn chunks(&self, chunk_size: usize) -> Chunks<'_, T>",
+          "description": "Returns an iterator over `chunk_size` elements of the slice at a time.",
+          "type": "method"
+        }
+      }
+    },
+    "HashMap": {
+      "signature": "pub struct HashMap<K, V, S = RandomState>",
+      "description": "A hash map implemented with quadratic probing and SIMD lookup. Requires keys to implement Eq and Hash.",
+      "type": "struct",
+      "module": "std::collections",
+      "members": {
+        "new": {
+          "signature": "pub fn new() -> HashMap<K, V>",
+          "description": "Creates an empty `HashMap`.",
+          "type": "method"
+        },
+        "insert": {
+          "signature": "pub fn insert(&mut self, k: K, v: V) -> Option<V>",
+          "description": "Inserts a key-value pair. If the key existed, the old value is returned.",
+          "type": "method"
+        },
+        "get": {
+          "signature": "pub fn get<Q: ?Sized>(&self, k: &Q) -> Option<&V> where K: Borrow<Q>, Q: Hash + Eq",
+          "description": "Returns a reference to the value corresponding to the key.",
+          "type": "method"
+        },
+        "get_mut": {
+          "signature": "pub fn get_mut<Q: ?Sized>(&mut self, k: &Q) -> Option<&mut V> where K: Borrow<Q>, Q: Hash + Eq",
+          "description": "Returns a mutable reference to the value corresponding to the key.",
+          "type": "method"
+        },
+        "remove": {
+          "signature": "pub fn remove<Q: ?Sized>(&mut self, k: &Q) -> Option<V> where K: Borrow<Q>, Q: Hash + Eq",
+          "description": "Removes a key from the map, returning the value if the key was present.",
+          "type": "method"
+        },
+        "contains_key": {
+          "signature": "pub fn contains_key<Q: ?Sized>(&self, k: &Q) -> bool where K: Borrow<Q>, Q: Hash + Eq",
+          "description": "Returns `true` if the map contains a value for the specified key.",
+          "type": "method"
+        },
+        "keys": {
+          "signature": "pub fn keys(&self) -> Keys<'_, K, V>",
+          "description": "Returns an iterator visiting all keys in arbitrary order.",
+          "type": "method"
+        },
+        "values": {
+          "signature": "pub fn values(&self) -> Values<'_, K, V>",
+          "description": "Returns an iterator visiting all values in arbitrary order.",
+          "type": "method"
+        },
+        "iter": {
+          "signature": "pub fn iter(&self) -> Iter<'_, K, V>",
+          "description": "Returns an iterator visiting all key-value pairs in arbitrary order.",
+          "type": "method"
+        },
+        "len": {
+          "signature": "pub fn len(&self) -> usize",
+          "description": "Returns the number of elements in the map.",
+          "type": "method"
+        },
+        "is_empty": {
+          "signature": "pub fn is_empty(&self) -> bool",
+          "description": "Returns `true` if the map contains no elements.",
+          "type": "method"
+        },
+        "entry": {
+          "signature": "pub fn entry(&mut self, key: K) -> Entry<'_, K, V>",
+          "description": "Gets the given key's corresponding entry in the map for in-place manipulation.",
+          "type": "method"
+        },
+        "extend": {
+          "signature": "pub fn extend<I: IntoIterator<Item = (K, V)>>(&mut self, iter: I)",
+          "description": "Extends the map with the contents of an iterator of key-value pairs.",
+          "type": "method"
+        },
+        "drain": {
+          "signature": "pub fn drain(&mut self) -> Drain<'_, K, V>",
+          "description": "Clears the map, returning all key-value pairs as an iterator.",
+          "type": "method"
+        },
+        "retain": {
+          "signature": "pub fn retain<F>(&mut self, f: F) where F: FnMut(&K, &mut V) -> bool",
+          "description": "Retains only the elements specified by the predicate.",
+          "type": "method"
+        }
+      }
+    },
+    "Option": {
+      "signature": "pub enum Option<T> { None, Some(T) }",
+      "description": "Represents an optional value. Every Option is either Some containing a value, or None.",
+      "type": "enum",
+      "module": "std::option",
+      "members": {
+        "Some": {
+          "signature": "Some(T)",
+          "description": "Contains the success value.",
+          "type": "variant"
+        },
+        "None": {
+          "signature": "None",
+          "description": "No value.",
+          "type": "variant"
+        },
+        "unwrap": {
+          "signature": "pub fn unwrap(self) -> T",
+          "description": "Returns the contained `Some` value. Panics if the value is `None`.",
+          "type": "method"
+        },
+        "unwrap_or": {
+          "signature": "pub fn unwrap_or(self, default: T) -> T",
+          "description": "Returns the contained `Some` value or a provided default.",
+          "type": "method"
+        },
+        "unwrap_or_else": {
+          "signature": "pub fn unwrap_or_else<F: FnOnce() -> T>(self, f: F) -> T",
+          "description": "Returns the contained `Some` value or computes it from a closure.",
+          "type": "method"
+        },
+        "unwrap_or_default": {
+          "signature": "pub fn unwrap_or_default(self) -> T where T: Default",
+          "description": "Returns the contained `Some` value or the default value of `T`.",
+          "type": "method"
+        },
+        "map": {
+          "signature": "pub fn map<U, F: FnOnce(T) -> U>(self, f: F) -> Option<U>",
+          "description": "Maps an `Option<T>` to `Option<U>` by applying a function to the contained value.",
+          "type": "method"
+        },
+        "and_then": {
+          "signature": "pub fn and_then<U, F: FnOnce(T) -> Option<U>>(self, f: F) -> Option<U>",
+          "description": "Returns `None` if the option is `None`, otherwise calls `f` with the wrapped value and returns the result. Also known as flat_map.",
+          "type": "method"
+        },
+        "or": {
+          "signature": "pub fn or(self, optb: Option<T>) -> Option<T>",
+          "description": "Returns the option if it contains a value, otherwise returns `optb`.",
+          "type": "method"
+        },
+        "or_else": {
+          "signature": "pub fn or_else<F: FnOnce() -> Option<T>>(self, f: F) -> Option<T>",
+          "description": "Returns the option if it contains a value, otherwise calls `f` and returns the result.",
+          "type": "method"
+        },
+        "filter": {
+          "signature": "pub fn filter<P: FnOnce(&T) -> bool>(self, predicate: P) -> Option<T>",
+          "description": "Returns `None` if the option is `None`, otherwise calls `predicate` and returns `Some(t)` if the predicate returns `true`.",
+          "type": "method"
+        },
+        "is_some": {
+          "signature": "pub fn is_some(&self) -> bool",
+          "description": "Returns `true` if the option is a `Some` value.",
+          "type": "method"
+        },
+        "is_none": {
+          "signature": "pub fn is_none(&self) -> bool",
+          "description": "Returns `true` if the option is a `None` value.",
+          "type": "method"
+        },
+        "ok_or": {
+          "signature": "pub fn ok_or<E>(self, err: E) -> Result<T, E>",
+          "description": "Transforms the `Option<T>` into a `Result<T, E>`, mapping `Some(v)` to `Ok(v)` and `None` to `Err(err)`.",
+          "type": "method"
+        },
+        "flatten": {
+          "signature": "pub fn flatten(self) -> Option<T> where T: Option<T>",
+          "description": "Converts from `Option<Option<T>>` to `Option<T>`.",
+          "type": "method"
+        },
+        "zip": {
+          "signature": "pub fn zip<U>(self, other: Option<U>) -> Option<(T, U)>",
+          "description": "Zips `self` with another `Option`. Returns `Some((a, b))` if both are `Some`, otherwise `None`.",
+          "type": "method"
+        },
+        "take": {
+          "signature": "pub fn take(&mut self) -> Option<T>",
+          "description": "Takes the value out of the option, leaving a `None` in its place.",
+          "type": "method"
+        }
+      }
+    },
+    "Result": {
+      "signature": "pub enum Result<T, E> { Ok(T), Err(E) }",
+      "description": "A type used for returning and propagating errors. Ok(T) represents success, Err(E) represents failure.",
+      "type": "enum",
+      "module": "std::result",
+      "members": {
+        "Ok": {
+          "signature": "Ok(T)",
+          "description": "Contains the success value.",
+          "type": "variant"
+        },
+        "Err": {
+          "signature": "Err(E)",
+          "description": "Contains the error value.",
+          "type": "variant"
+        },
+        "unwrap": {
+          "signature": "pub fn unwrap(self) -> T where E: Debug",
+          "description": "Returns the contained `Ok` value. Panics if the value is an `Err`, with a panic message from the error's `Debug` impl.",
+          "type": "method"
+        },
+        "unwrap_or": {
+          "signature": "pub fn unwrap_or(self, default: T) -> T",
+          "description": "Returns the contained `Ok` value or a provided default.",
+          "type": "method"
+        },
+        "unwrap_err": {
+          "signature": "pub fn unwrap_err(self) -> E where T: Debug",
+          "description": "Returns the contained `Err` value. Panics if the value is `Ok`.",
+          "type": "method"
+        },
+        "map": {
+          "signature": "pub fn map<U, F: FnOnce(T) -> U>(self, op: F) -> Result<U, E>",
+          "description": "Maps a `Result<T, E>` to `Result<U, E>` by applying a function to a contained `Ok` value.",
+          "type": "method"
+        },
+        "map_err": {
+          "signature": "pub fn map_err<F, O: FnOnce(E) -> F>(self, op: O) -> Result<T, F>",
+          "description": "Maps a `Result<T, E>` to `Result<T, F>` by applying a function to a contained `Err` value.",
+          "type": "method"
+        },
+        "and_then": {
+          "signature": "pub fn and_then<U, F: FnOnce(T) -> Result<U, E>>(self, op: F) -> Result<U, E>",
+          "description": "Calls `op` if the result is `Ok`, otherwise returns the `Err` value of self.",
+          "type": "method"
+        },
+        "or": {
+          "signature": "pub fn or<F>(self, res: Result<T, F>) -> Result<T, F>",
+          "description": "Returns `res` if the result is `Err`, otherwise returns the `Ok` value of self.",
+          "type": "method"
+        },
+        "or_else": {
+          "signature": "pub fn or_else<F, O: FnOnce(E) -> Result<T, F>>(self, op: O) -> Result<T, F>",
+          "description": "Calls `op` if the result is `Err`, otherwise returns the `Ok` value of self.",
+          "type": "method"
+        },
+        "is_ok": {
+          "signature": "pub fn is_ok(&self) -> bool",
+          "description": "Returns `true` if the result is `Ok`.",
+          "type": "method"
+        },
+        "is_err": {
+          "signature": "pub fn is_err(&self) -> bool",
+          "description": "Returns `true` if the result is `Err`.",
+          "type": "method"
+        },
+        "ok": {
+          "signature": "pub fn ok(self) -> Option<T>",
+          "description": "Converts from `Result<T, E>` to `Option<T>`, discarding the error.",
+          "type": "method"
+        },
+        "err": {
+          "signature": "pub fn err(self) -> Option<E>",
+          "description": "Converts from `Result<T, E>` to `Option<E>`, discarding the success value.",
+          "type": "method"
+        },
+        "expect": {
+          "signature": "pub fn expect(self, msg: &str) -> T where E: Debug",
+          "description": "Returns the contained `Ok` value. Panics with the provided message if `Err`.",
+          "type": "method"
+        }
+      }
+    },
+    "Box": {
+      "signature": "pub struct Box<T: ?Sized>",
+      "description": "A pointer type for heap allocation. Box<T> provides ownership of a heap-allocated value of type T.",
+      "type": "struct",
+      "module": "std::boxed",
+      "members": {
+        "new": {
+          "signature": "pub fn new(x: T) -> Box<T>",
+          "description": "Allocates memory on the heap and places `x` into it.",
+          "type": "method"
+        },
+        "into_raw": {
+          "signature": "pub fn into_raw(b: Box<T>) -> *mut T",
+          "description": "Consumes the `Box`, returning a raw pointer. The caller is responsible for freeing the memory.",
+          "type": "method"
+        },
+        "from_raw": {
+          "signature": "pub unsafe fn from_raw(raw: *mut T) -> Box<T>",
+          "description": "Constructs a `Box<T>` from a raw pointer. Undefined behavior if the pointer was not allocated by `Box`.",
+          "type": "method"
+        },
+        "leak": {
+          "signature": "pub fn leak<'a>(b: Box<T>) -> &'a mut T",
+          "description": "Consumes and leaks the `Box`, returning a mutable reference with a `'static` lifetime.",
+          "type": "method"
+        }
+      }
+    },
+    "Rc": {
+      "signature": "pub struct Rc<T: ?Sized>",
+      "description": "A single-threaded reference-counting pointer. Rc provides shared ownership of a value of type T, allocated on the heap.",
+      "type": "struct",
+      "module": "std::rc",
+      "members": {
+        "new": {
+          "signature": "pub fn new(value: T) -> Rc<T>",
+          "description": "Constructs a new `Rc<T>`.",
+          "type": "method"
+        },
+        "clone": {
+          "signature": "pub fn clone(this: &Rc<T>) -> Rc<T>",
+          "description": "Creates a new pointer to the same allocation, incrementing the reference count.",
+          "type": "method"
+        },
+        "strong_count": {
+          "signature": "pub fn strong_count(this: &Rc<T>) -> usize",
+          "description": "Gets the number of strong (`Rc`) pointers to this allocation.",
+          "type": "method"
+        },
+        "try_unwrap": {
+          "signature": "pub fn try_unwrap(this: Rc<T>) -> Result<T, Rc<T>>",
+          "description": "Returns the inner value if the `Rc` has exactly one strong reference.",
+          "type": "method"
+        },
+        "downgrade": {
+          "signature": "pub fn downgrade(this: &Rc<T>) -> Weak<T>",
+          "description": "Creates a new `Weak` pointer to this allocation.",
+          "type": "method"
+        }
+      }
+    },
+    "Arc": {
+      "signature": "pub struct Arc<T: ?Sized>",
+      "description": "A thread-safe reference-counting pointer. Arc stands for Atomically Reference Counted.",
+      "type": "struct",
+      "module": "std::sync",
+      "members": {
+        "new": {
+          "signature": "pub fn new(data: T) -> Arc<T>",
+          "description": "Constructs a new `Arc<T>`.",
+          "type": "method"
+        },
+        "clone": {
+          "signature": "pub fn clone(this: &Arc<T>) -> Arc<T>",
+          "description": "Creates a new pointer to the same allocation, atomically incrementing the reference count.",
+          "type": "method"
+        },
+        "strong_count": {
+          "signature": "pub fn strong_count(this: &Arc<T>) -> usize",
+          "description": "Gets the number of strong (`Arc`) pointers to this allocation.",
+          "type": "method"
+        },
+        "try_unwrap": {
+          "signature": "pub fn try_unwrap(this: Arc<T>) -> Result<T, Arc<T>>",
+          "description": "Returns the inner value if the `Arc` has exactly one strong reference.",
+          "type": "method"
+        },
+        "downgrade": {
+          "signature": "pub fn downgrade(this: &Arc<T>) -> Weak<T>",
+          "description": "Creates a new `Weak` pointer to this allocation.",
+          "type": "method"
+        }
+      }
+    },
+    "Iterator": {
+      "signature": "pub trait Iterator",
+      "description": "A trait for dealing with iterators. Only the next method is required; all other methods have default implementations.",
+      "type": "trait",
+      "module": "std::iter",
+      "members": {
+        "next": {
+          "signature": "fn next(&mut self) -> Option<Self::Item>",
+          "description": "Advances the iterator and returns the next value. Returns `None` when iteration is complete.",
+          "type": "method"
+        },
+        "map": {
+          "signature": "fn map<B, F: FnMut(Self::Item) -> B>(self, f: F) -> Map<Self, F>",
+          "description": "Takes a closure and creates an iterator that calls that closure on each element.",
+          "type": "method"
+        },
+        "filter": {
+          "signature": "fn filter<P: FnMut(&Self::Item) -> bool>(self, predicate: P) -> Filter<Self, P>",
+          "description": "Creates an iterator that only yields elements matching the predicate.",
+          "type": "method"
+        },
+        "fold": {
+          "signature": "fn fold<B, F: FnMut(B, Self::Item) -> B>(self, init: B, f: F) -> B",
+          "description": "Folds every element into an accumulator by applying a closure, returning the final result.",
+          "type": "method"
+        },
+        "collect": {
+          "signature": "fn collect<B: FromIterator<Self::Item>>(self) -> B",
+          "description": "Transforms an iterator into a collection. Can collect into Vec, HashMap, String, etc.",
+          "type": "method"
+        },
+        "enumerate": {
+          "signature": "fn enumerate(self) -> Enumerate<Self>",
+          "description": "Creates an iterator that yields `(index, value)` pairs.",
+          "type": "method"
+        },
+        "zip": {
+          "signature": "fn zip<U: IntoIterator>(self, other: U) -> Zip<Self, U::IntoIter>",
+          "description": "Zips two iterators into a single iterator of pairs.",
+          "type": "method"
+        },
+        "take": {
+          "signature": "fn take(self, n: usize) -> Take<Self>",
+          "description": "Creates an iterator that yields at most `n` elements.",
+          "type": "method"
+        },
+        "skip": {
+          "signature": "fn skip(self, n: usize) -> Skip<Self>",
+          "description": "Creates an iterator that skips the first `n` elements.",
+          "type": "method"
+        },
+        "chain": {
+          "signature": "fn chain<U: IntoIterator<Item = Self::Item>>(self, other: U) -> Chain<Self, U::IntoIter>",
+          "description": "Creates an iterator that chains two iterators together, yielding elements from the first then the second.",
+          "type": "method"
+        },
+        "flatten": {
+          "signature": "fn flatten(self) -> Flatten<Self> where Self::Item: IntoIterator",
+          "description": "Creates an iterator that flattens nested structure.",
+          "type": "method"
+        },
+        "any": {
+          "signature": "fn any<F: FnMut(Self::Item) -> bool>(&mut self, f: F) -> bool",
+          "description": "Tests if any element of the iterator matches a predicate.",
+          "type": "method"
+        },
+        "all": {
+          "signature": "fn all<F: FnMut(Self::Item) -> bool>(&mut self, f: F) -> bool",
+          "description": "Tests if every element of the iterator matches a predicate.",
+          "type": "method"
+        },
+        "find": {
+          "signature": "fn find<P: FnMut(&Self::Item) -> bool>(&mut self, predicate: P) -> Option<Self::Item>",
+          "description": "Searches for an element that satisfies the predicate.",
+          "type": "method"
+        },
+        "position": {
+          "signature": "fn position<P: FnMut(Self::Item) -> bool>(&mut self, predicate: P) -> Option<usize>",
+          "description": "Searches for an element, returning its index.",
+          "type": "method"
+        },
+        "count": {
+          "signature": "fn count(self) -> usize",
+          "description": "Consumes the iterator, counting the number of elements.",
+          "type": "method"
+        },
+        "sum": {
+          "signature": "fn sum<S: Sum<Self::Item>>(self) -> S",
+          "description": "Sums the elements of an iterator.",
+          "type": "method"
+        },
+        "product": {
+          "signature": "fn product<P: Product<Self::Item>>(self) -> P",
+          "description": "Iterates over the entire iterator, multiplying all elements.",
+          "type": "method"
+        },
+        "min": {
+          "signature": "fn min(self) -> Option<Self::Item> where Self::Item: Ord",
+          "description": "Returns the minimum element of an iterator.",
+          "type": "method"
+        },
+        "max": {
+          "signature": "fn max(self) -> Option<Self::Item> where Self::Item: Ord",
+          "description": "Returns the maximum element of an iterator.",
+          "type": "method"
+        },
+        "cloned": {
+          "signature": "fn cloned<'a, T: 'a + Clone>(self) -> Cloned<Self> where Self: Iterator<Item = &'a T>",
+          "description": "Creates an iterator that clones all of its elements.",
+          "type": "method"
+        },
+        "copied": {
+          "signature": "fn copied<'a, T: 'a + Copy>(self) -> Copied<Self> where Self: Iterator<Item = &'a T>",
+          "description": "Creates an iterator that copies all of its elements.",
+          "type": "method"
+        },
+        "peekable": {
+          "signature": "fn peekable(self) -> Peekable<Self>",
+          "description": "Creates an iterator that can use the `peek` method to look at the next element without consuming it.",
+          "type": "method"
+        },
+        "rev": {
+          "signature": "fn rev(self) -> Rev<Self> where Self: DoubleEndedIterator",
+          "description": "Reverses an iterator's direction.",
+          "type": "method"
+        }
+      }
+    },
+    "Mutex": {
+      "signature": "pub struct Mutex<T: ?Sized>",
+      "description": "A mutual exclusion primitive useful for protecting shared data.",
+      "type": "struct",
+      "module": "std::sync",
+      "members": {
+        "new": {
+          "signature": "pub fn new(t: T) -> Mutex<T>",
+          "description": "Creates a new mutex in an unlocked state.",
+          "type": "method",
+          "returns": "Mutex<T>"
+        },
+        "lock": {
+          "signature": "pub fn lock(&self) -> LockResult<MutexGuard<'_, T>>",
+          "description": "Acquires a mutex, blocking the current thread until it can.",
+          "type": "method",
+          "returns": "LockResult<MutexGuard<T>>"
+        },
+        "try_lock": {
+          "signature": "pub fn try_lock(&self) -> TryLockResult<MutexGuard<'_, T>>",
+          "description": "Attempts to acquire without blocking.",
+          "type": "method",
+          "returns": "TryLockResult<MutexGuard<T>>"
+        },
+        "into_inner": {
+          "signature": "pub fn into_inner(self) -> LockResult<T>",
+          "description": "Consumes this mutex, returning the underlying data.",
+          "type": "method",
+          "returns": "LockResult<T>"
+        }
+      }
+    },
+    "File": {
+      "signature": "pub struct File",
+      "description": "A reference to an open file on the filesystem.",
+      "type": "struct",
+      "module": "std::fs",
+      "members": {
+        "open": {
+          "signature": "pub fn open<P: AsRef<Path>>(path: P) -> io::Result<File>",
+          "description": "Opens a file in read-only mode.",
+          "type": "method",
+          "returns": "io::Result<File>"
+        },
+        "create": {
+          "signature": "pub fn create<P: AsRef<Path>>(path: P) -> io::Result<File>",
+          "description": "Opens a file in write-only mode, creating or truncating.",
+          "type": "method",
+          "returns": "io::Result<File>"
+        },
+        "read_to_string": {
+          "signature": "pub fn read_to_string(path: impl AsRef<Path>) -> io::Result<String>",
+          "description": "Read the entire contents of a file into a string.",
+          "type": "method",
+          "returns": "io::Result<String>"
+        },
+        "write": {
+          "signature": "pub fn write(path: impl AsRef<Path>, contents: impl AsRef<[u8]>) -> io::Result<()>",
+          "description": "Write a slice as the entire contents of a file.",
+          "type": "method",
+          "returns": "io::Result<()>"
+        },
+        "metadata": {
+          "signature": "pub fn metadata(&self) -> io::Result<Metadata>",
+          "description": "Queries metadata about the file.",
+          "type": "method",
+          "returns": "io::Result<Metadata>"
+        }
+      }
+    },
+    "Path": {
+      "signature": "pub struct Path",
+      "description": "A slice of a path. This type supports inspection and manipulation of paths.",
+      "type": "struct",
+      "module": "std::path",
+      "members": {
+        "new": {
+          "signature": "pub fn new<S: AsRef<OsStr> + ?Sized>(s: &S) -> &Path",
+          "description": "Creates a new Path from a string.",
+          "type": "method",
+          "returns": "&Path"
+        },
+        "exists": {
+          "signature": "pub fn exists(&self) -> bool",
+          "description": "Returns true if the path points at an existing entity.",
+          "type": "method",
+          "returns": "bool"
+        },
+        "is_file": {
+          "signature": "pub fn is_file(&self) -> bool",
+          "description": "Returns true if the path is an existing regular file.",
+          "type": "method",
+          "returns": "bool"
+        },
+        "is_dir": {
+          "signature": "pub fn is_dir(&self) -> bool",
+          "description": "Returns true if the path is an existing directory.",
+          "type": "method",
+          "returns": "bool"
+        },
+        "extension": {
+          "signature": "pub fn extension(&self) -> Option<&OsStr>",
+          "description": "Extracts the extension.",
+          "type": "method",
+          "returns": "Option<&OsStr>"
+        },
+        "file_name": {
+          "signature": "pub fn file_name(&self) -> Option<&OsStr>",
+          "description": "Returns the final component of the Path.",
+          "type": "method",
+          "returns": "Option<&OsStr>"
+        },
+        "parent": {
+          "signature": "pub fn parent(&self) -> Option<&Path>",
+          "description": "Returns the Path without its final component.",
+          "type": "method",
+          "returns": "Option<&Path>"
+        },
+        "join": {
+          "signature": "pub fn join<P: AsRef<Path>>(&self, path: P) -> PathBuf",
+          "description": "Creates an owned PathBuf with path adjoined.",
+          "type": "method",
+          "returns": "PathBuf"
+        }
+      }
+    }
+  }
 }