@enjoys/context-engine 1.0.0 → 1.0.2

package/data/defination/rust.json

@@ -0,0 +1,207 @@
+{
+  "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" }
+      }
+    }
+  }
+}