three-d

https://docs.rs/three-d/latest/
Admin
A 3D renderer that enables building applications for both desktop and web platforms using the same...
Tokens:836,800
Snippets:6,695
Trust Score:9.7
Update:6 months ago
Show doc for...
Tokens:
Raw
### Check if slice starts with a prefix

Source: https://docs.rs/three-d/latest/three_d/renderer/object/struct.Model.html

Use `starts_with` to determine if a slice begins with a specified sequence of elements. An empty prefix always returns true.

```rust
let v = [10, 40, 30];
assert!(v.starts_with(&[10]));
assert!(v.starts_with(&[10, 40]));
assert!(v.starts_with(&v));
assert!(!v.starts_with(&[50]));
assert!(!v.starts_with(&[10, 50]));
```

```rust
let v = &[10, 40, 30];
assert!(v.starts_with(&[]));
let v: &[u8] = &[];
assert!(v.starts_with(&[]));
```

--------------------------------

### strip_prefix

Source: https://docs.rs/three-d/latest/three_d/renderer/object/struct.Model.html

Returns a subslice with the prefix removed. If the slice starts with `prefix`, returns the subslice after the prefix, wrapped in `Some`. If `prefix` is empty, simply returns the original slice. If `prefix` is equal to the original slice, returns an empty slice. If the slice does not start with `prefix`, returns `None`.

```APIDOC
## pub fn strip_prefix<P>(&self, prefix: &P) -> Option<&[T]>
where P: SlicePattern<Item = T> + ?Sized, T: PartialEq

### Description
Returns a subslice with the prefix removed. If the slice starts with `prefix`, returns the subslice after the prefix, wrapped in `Some`. If `prefix` is empty, simply returns the original slice. If `prefix` is equal to the original slice, returns an empty slice. If the slice does not start with `prefix`, returns `None`.

### Method
`strip_prefix`

### Endpoint
None (method on slice)

### Parameters
#### Path Parameters
None

#### Query Parameters
None

#### Request Body
None

### Request Example
```rust
let v = &[10, 40, 30];
assert_eq!(v.strip_prefix(&[10]), Some(&[40, 30][..]));
assert_eq!(v.strip_prefix(&[10, 40]), Some(&[30][..]));
assert_eq!(v.strip_prefix(&[10, 40, 30]), Some(&[][..]));
assert_eq!(v.strip_prefix(&[50]), None);
assert_eq!(v.strip_prefix(&[10, 50]), None);

let prefix : &str = "he";
assert_eq!(b"hello".strip_prefix(prefix.as_bytes()),
           Some(b"llo".as_ref()));
```

### Response
#### Success Response (200)
An `Option` containing the subslice after the prefix if it exists, otherwise `None`.

#### Response Example
```json
{
  "example": "Some(&[40, 30][..])"
}
```
```

--------------------------------

### Get Element Offset in Slice

Source: https://docs.rs/three-d/latest/three_d/renderer/object/struct.Model.html

Returns the index of an element reference within a slice using pointer arithmetic. Returns `None` if the element reference does not point to the start of an element. This is a nightly-only experimental API.

```rust
#![feature(substr_range)]

let nums: &[u32] = &[1, 7, 1, 1];
let num = &nums[2];

assert_eq!(num, &1);
assert_eq!(nums.element_offset(num), Some(2));
```

```rust
#![feature(substr_range)]

let arr: &[[u32; 2]] = &[[0, 1], [2, 3]];
let flat_arr: &[u32] = arr.as_flattened();

let ok_elm: &[u32; 2] = flat_arr[0..2].try_into().unwrap();
let weird_elm: &[u32; 2] = flat_arr[1..3].try_into().unwrap();

assert_eq!(ok_elm, &[0, 1]);
assert_eq!(weird_elm, &[1, 2]);

assert_eq!(arr.element_offset(ok_elm), Some(0)); // Points to element 0
assert_eq!(arr.element_offset(weird_elm), None); // Points between element 0 and 1
```

--------------------------------

### Get Disjoint Mutable References

Source: https://docs.rs/three-d/latest/three_d/renderer/object/struct.Model.html

Returns mutable references to multiple elements at once, performing checks for out-of-bounds and overlapping indices. Available since version 1.86.0.

```APIDOC
## POST /api/slice/get_disjoint_mut

### Description
Returns mutable references to many indices at once. An index can be either a `usize`, a `Range` or a `RangeInclusive`. This method takes an array, so all indices must be of the same type. Returns an error if any index is out-of-bounds, or if there are overlapping indices.

### Method
POST

### Endpoint
/api/slice/get_disjoint_mut

### Parameters
#### Request Body
- **slice** (array) - Required - The slice to get references from.
- **indices** (array) - Required - An array of indices (usize, Range, or RangeInclusive) to get mutable references for.

### Request Example
```json
{
  "slice": [1, 2, 3],
  "indices": [0, 2]
}
```

### Response
#### Success Response (200)
- **references** (array) - An array of mutable references to the elements at the specified indices.

#### Error Response (400)
- **error** (string) - Description of the error (e.g., out of bounds, overlapping indices).

#### Response Example
```json
{
  "references": ["&mut 413", "&mut 612"]
}
```
```

--------------------------------

### Split Off Slice Starting with Third Element

Source: https://docs.rs/three-d/latest/three_d/renderer/object/struct.Model.html

Removes a subslice starting from the third element (index 2) and returns a reference to it. The original slice is updated to exclude the removed part. This method accepts one-sided ranges like `2..`.

```rust
let mut slice: &[_] = &['a', 'b', 'c', 'd'];
let mut tail = slice.split_off(2..).unwrap();

assert_eq!(slice, &['a', 'b']);
assert_eq!(tail, &['c', 'd']);
```

--------------------------------

### Remove and Get First Element of a Slice

Source: https://docs.rs/three-d/latest/three_d/renderer/object/struct.Model.html

Removes the first element from a slice and returns a reference to it. The original slice is modified to exclude the first element. Returns `None` if the slice is empty.

```rust
let mut slice: &[_] = &['a', 'b', 'c'];
let first = slice.split_off_first().unwrap();

assert_eq!(slice, &['b', 'c']);
assert_eq!(first, &'a');
```

--------------------------------

### Remove a prefix from a slice

Source: https://docs.rs/three-d/latest/three_d/renderer/object/struct.Model.html

Use `strip_prefix` to get a subslice with the leading elements removed if they match the provided prefix. Returns `None` if the prefix does not match.

```rust
let v = &[10, 40, 30];
assert_eq!(v.strip_prefix(&[10]), Some(&[40, 30][..]));
assert_eq!(v.strip_prefix(&[10, 40]), Some(&[30][..]));
assert_eq!(v.strip_prefix(&[10, 40, 30]), Some(&[][..]));
assert_eq!(v.strip_prefix(&[50]), None);
assert_eq!(v.strip_prefix(&[10, 50]), None);

let prefix : &str = "he";
assert_eq!(b"hello".strip_prefix(prefix.as_bytes()),
           Some(b"llo".as_ref()));
```

--------------------------------

### Get Disjoint Mutable References Safely

Source: https://docs.rs/three-d/latest/three_d/renderer/object/struct.Model.html

Safely retrieves multiple disjoint mutable references from a slice, returning an error if indices are out of bounds or overlapping. This method performs an O(n^2) check for overlaps.

```rust
let v = &mut [1, 2, 3];
if let Ok([a, b]) = v.get_disjoint_mut([0, 2]) {
    *a = 413;
    *b = 612;
}
assert_eq!(v, &[413, 2, 612]);
```

```rust
let v = &mut [1, 2, 3];
if let Ok([a, b]) = v.get_disjoint_mut([0..1, 1..3]) {
    a[0] = 8;
    b[0] = 88;
    b[1] = 888;
}
assert_eq!(v, &[8, 88, 888]);
```

```rust
let v = &mut [1, 2, 3];
if let Ok([a, b]) = v.get_disjoint_mut([1..=2, 0..=0]) {
    a[0] = 11;
    a[1] = 111;
    b[0] = 1;
}
assert_eq!(v, &[1, 11, 111]);
```

--------------------------------

### Remove and Get First Element Mutably from a Slice

Source: https://docs.rs/three-d/latest/three_d/renderer/object/struct.Model.html

Removes the first element from a mutable slice and returns a mutable reference to it. The original mutable slice is modified to exclude the first element. Returns `None` if the slice is empty.

```rust
let mut slice: &mut [_] = &mut ['a', 'b', 'c'];
let first = slice.split_off_first_mut().unwrap();
*first = 'd';

assert_eq!(slice, &['b', 'c']);
assert_eq!(first, &'d');
```

--------------------------------

### Get Disjoint Unchecked Mutable References

Source: https://docs.rs/three-d/latest/three_d/renderer/object/struct.Model.html

Returns mutable references to multiple elements at once without performing bounds or overlap checks. This is an unsafe operation and requires careful usage. Available since version 1.86.0.

```APIDOC
## POST /api/slice/get_disjoint_unchecked_mut

### Description
Returns mutable references to many indices at once, without doing any checks. An index can be either a `usize`, a `Range` or a `RangeInclusive`. This method takes an array, so all indices must be of the same type.

### Method
POST

### Endpoint
/api/slice/get_disjoint_unchecked_mut

### Parameters
#### Request Body
- **slice** (array) - Required - The slice to get references from.
- **indices** (array) - Required - An array of indices (usize, Range, or RangeInclusive) to get mutable references for.

### Request Example
```json
{
  "slice": [1, 2, 4],
  "indices": [0, 2]
}
```

### Response
#### Success Response (200)
- **references** (array) - An array of mutable references to the elements at the specified indices.

#### Response Example
```json
{
  "references": ["&mut 10", "&mut 400"]
}
```
```

--------------------------------

### rsplitn_mut

Source: https://docs.rs/three-d/latest/three_d/renderer/object/struct.Model.html

Returns an iterator over subslices separated by elements that match `pred` limited to returning at most `n` items. This starts at the end of the slice and works backwards. The matched element is not contained in the subslices. The last element returned, if any, will contain the remainder of the slice.

```APIDOC
## pub fn rsplitn_mut<F>(&mut self, n: usize, pred: F) -> RSplitNMut<'_, T, F>
where F: FnMut(&T) -> bool

### Description
Returns an iterator over subslices separated by elements that match `pred` limited to returning at most `n` items. This starts at the end of the slice and works backwards. The matched element is not contained in the subslices. The last element returned, if any, will contain the remainder of the slice.

### Method
`rsplitn_mut`

### Parameters
#### Path Parameters
None

#### Query Parameters
None

#### Request Body
None

### Request Example
```rust
let mut s = [10, 40, 30, 20, 60, 50];

for group in s.rsplitn_mut(2, |num| *num % 3 == 0) {
    group[0] = 1;
}
assert_eq!(s, [1, 40, 30, 20, 60, 1]);
```

### Response
#### Success Response (200)
Iterator over mutable subslices.

#### Response Example
None provided.
```

--------------------------------

### starts_with

Source: https://docs.rs/three-d/latest/three_d/renderer/object/struct.Model.html

Returns `true` if `needle` is a prefix of the slice or equal to the slice.

```APIDOC
## pub fn starts_with(&self, needle: &[T]) -> bool
where T: PartialEq

### Description
Returns `true` if `needle` is a prefix of the slice or equal to the slice.

### Method
`starts_with`

### Endpoint
None (method on slice)

### Parameters
#### Path Parameters
None

#### Query Parameters
None

#### Request Body
None

### Request Example
```rust
let v = [10, 40, 30];
assert!(v.starts_with(&[10]));
assert!(v.starts_with(&[10, 40]));
assert!(v.starts_with(&v));
assert!(!v.starts_with(&[50]));
assert!(!v.starts_with(&[10, 50]));

let v = &[10, 40, 30];
assert!(v.starts_with(&[]));
let v: &[u8] = &[];
assert!(v.starts_with(&[]));
```

### Response
#### Success Response (200)
`true` if the slice starts with the `needle`, `false` otherwise.

#### Response Example
```json
{
  "example": "true"
}
```
```

--------------------------------

### Inserting into a Sorted Vector with partition_point

Source: https://docs.rs/three-d/latest/three_d/renderer/object/struct.Model.html

Demonstrates inserting an element into a sorted vector while maintaining sort order using `partition_point`. This method can be more efficient than shifting elements if the insertion point is known.

```rust
let mut s = vec![0, 1, 1, 1, 1, 2, 3, 5, 8, 13, 21, 34, 55];
let num = 42;
let idx = s.partition_point(|&x| x <= num);
// If `num` is unique, `s.partition_point(|&x| x < num)` (with `<`) is equivalent to
// `s.binary_search(&num).unwrap_or_else(|x| x)`, but using `<=` will allow `insert`
// to shift less elements.
s.insert(idx, num);
assert_eq!(s, [0, 1, 1, 1, 1, 2, 3, 5, 8, 13, 21, 34, 42, 55]);
```

--------------------------------

### as_simd

Source: https://docs.rs/three-d/latest/three_d/renderer/object/struct.Model.html

Splits a slice into a prefix, a middle of aligned SIMD types, and a suffix.

```APIDOC
## as_simd<const LANES: usize>(&self)

### Description
Splits a slice into a prefix, a middle of aligned SIMD types, and a suffix. This is a safe wrapper around slice::align_to.

### Parameters
#### Path Parameters
- **LANES** (usize) - Required - The number of lanes for the SIMD type.

### Panics
This will panic if the size of the SIMD type is different from LANES times that of the scalar.
```

--------------------------------

### Split Off Slice Starting with Third Element Mutably

Source: https://docs.rs/three-d/latest/three_d/renderer/object/struct.Model.html

Removes a mutable subslice starting from the third element (index 2) and returns a mutable reference to it. The original mutable slice is updated to exclude the removed part. This method accepts one-sided ranges like `2..`.

```rust
let mut slice: &mut [_] = &mut ['a', 'b', 'c', 'd'];
let mut tail = slice.split_off_mut(2..).unwrap();

assert_eq!(slice, &mut ['a', 'b']);
assert_eq!(tail, &mut ['c', 'd']);
```

--------------------------------

### fill

Source: https://docs.rs/three-d/latest/three_d/renderer/object/struct.Model.html

Fills the slice with elements by cloning a given value.

```APIDOC
## fill

### Description
Fills `self` with elements by cloning `value`.

### Method
`fill(&mut self, value: T) where T: Clone`

### Parameters
#### Path Parameters
- **value** (T) - Required - The value to clone and fill the slice with.

### Examples
```rust
let mut buf = vec![0; 10];
buf.fill(1);
assert_eq!(buf, vec![1; 10]);
```
```

--------------------------------

### Partition Slice by Key

Source: https://docs.rs/three-d/latest/three_d/renderer/object/struct.Model.html

Partitions a slice into two based on a key extracted from each element. Elements for which the key is equal are grouped together.

```rust
#![feature(slice_partition_dedup)]

let mut slice = [10, 20, 21, 30, 30, 20, 11, 13];

let (dedup, duplicates) = slice.partition_dedup_by_key(|i| *i / 10);

assert_eq!(dedup, [10, 20, 30, 20, 11]);
assert_eq!(duplicates, [21, 30, 13]);

```

--------------------------------

### Copy Slice from Slice

Source: https://docs.rs/three-d/latest/three_d/renderer/object/struct.Model.html

Copies elements from a source slice to a destination slice using `memcpy`. Both slices must have the same length and elements must implement `Copy`.

```rust
let mut self = [0; 3];
let src = [1, 2, 3];
self.copy_from_slice(&src);
assert_eq!(self, [1, 2, 3]);

```

--------------------------------

### Get Disjoint Unchecked Mutable References

Source: https://docs.rs/three-d/latest/three_d/renderer/object/struct.Model.html

Unsafely retrieves multiple disjoint mutable references from a slice without bounds or overlap checks. Behavior is undefined if indices are out of bounds or overlapping.

```rust
let x = &mut [1, 2, 4];

unsafe {
    let [a, b] = x.get_disjoint_unchecked_mut([0, 2]);
    *a *= 10;
    *b *= 100;
}
assert_eq!(x, &[10, 2, 400]);
```

```rust
let x = &mut [1, 2, 4];

unsafe {
    let [a, b] = x.get_disjoint_unchecked_mut([0..1, 1..3]);
    a[0] = 8;
    b[0] = 88;
    b[1] = 888;
}
assert_eq!(x, &[8, 88, 888]);
```

```rust
let x = &mut [1, 2, 4];

unsafe {
    let [a, b] = x.get_disjoint_unchecked_mut([1..=2, 0..=0]);
    a[0] = 11;
    a[1] = 111;
    b[0] = 1;
}
assert_eq!(x, &[1, 11, 111]);
```

--------------------------------

### pub fn sort_by_key<K, F>(&mut self, f: F)

Source: https://docs.rs/three-d/latest/three_d/renderer/object/struct.Model.html

Sorts the slice in ascending order with a key extraction function, preserving initial order of equal elements.

```APIDOC
## sort_by_key

### Description
Sorts the slice using a key extraction function. This is a stable sort with O(m * n * log(n)) worst-case complexity.

### Parameters
#### Request Body
- **f** (FnMut(&T) -> K) - Required - Key extraction function where K implements Ord.

### Request Example
```rust
let mut v = [4i32, -5, 1, -3, 2];
v.sort_by_key(|k| k.abs());
```
```

--------------------------------

### Remove and Get Last Element of a Slice

Source: https://docs.rs/three-d/latest/three_d/renderer/object/struct.Model.html

Removes the last element from a slice and returns a reference to it. The original slice is modified to exclude the last element. Returns `None` if the slice is empty.

```rust
let mut slice: &[_] = &['a', 'b', 'c'];
let last = slice.split_off_last().unwrap();

assert_eq!(slice, &['a', 'b']);
assert_eq!(last, &'c');
```

--------------------------------

### fill_with

Source: https://docs.rs/three-d/latest/three_d/renderer/object/struct.Model.html

Fills the slice with elements generated by repeatedly calling a closure.

```APIDOC
## fill_with

### Description
Fills `self` with elements returned by calling a closure repeatedly. This method uses a closure to create new values. If you’d rather `Clone` a given value, use `fill`. If you want to use the `Default` trait to generate values, you can pass `Default::default` as the argument.

### Method
`fill_with<F>(&mut self, f: F) where F: FnMut() -> T`

### Parameters
#### Path Parameters
- **f** (F) - Required - A closure that returns a value of type T to fill the slice with.

### Examples
```rust
let mut buf = vec![1; 10];
buf.fill_with(Default::default);
assert_eq!(buf, vec![0; 10]);
```
```

--------------------------------

### Copying elements between slices

Source: https://docs.rs/three-d/latest/three_d/renderer/object/struct.Model.html

Demonstrates copying elements from one slice to another. Note that the destination slice must be the same length as the source range.

```rust
let src = [1, 2, 3, 4];
let mut dst = [0, 0];

// Because the slices have to be the same length,
// we slice the source slice from four elements
// to two. It will panic if we don't do this.
dst.copy_from_slice(&src[2..]);

assert_eq!(src, [1, 2, 3, 4]);
assert_eq!(dst, [3, 4]);
```

```rust
let mut slice = [1, 2, 3, 4, 5];

slice[..2].copy_from_slice(&slice[3..]); // compile fail!
```

```rust
let mut slice = [1, 2, 3, 4, 5];

{
    let (left, right) = slice.split_at_mut(2);
    left.copy_from_slice(&right[1..]);
}

assert_eq!(slice, [4, 5, 3, 4, 5]);
```

--------------------------------

### split_once

Source: https://docs.rs/three-d/latest/three_d/renderer/object/struct.Model.html

Splits the slice on the first element that matches the specified predicate. If any matching elements are present in the slice, returns the prefix before the match and suffix after. The matching element itself is not included. If no elements match, returns `None`. This is a nightly-only experimental API.

```APIDOC
## pub fn split_once<F>(&self, pred: F) -> Option<(&[T], &[T])>
where F: FnMut(&T) -> bool

### Description
Splits the slice on the first element that matches the specified predicate. If any matching elements are present in the slice, returns the prefix before the match and suffix after. The matching element itself is not included. If no elements match, returns `None`. This is a nightly-only experimental API.

### Method
`split_once`

### Endpoint
None (method on slice)

### Parameters
#### Path Parameters
None

#### Query Parameters
None

#### Request Body
None

### Request Example
```rust
#![feature(slice_split_once)]
let s = [1, 2, 3, 2, 4];
assert_eq!(s.split_once(|&x| x == 2), Some((
    &[1][..],
    &[3, 2, 4][..]
)));
assert_eq!(s.split_once(|&x| x == 0), None);
```

### Response
#### Success Response (200)
An `Option` containing a tuple of two subslices (`(&[T], &[T])`) if a match is found, otherwise `None`.

#### Response Example
```json
{
  "example": "Some((&[1][..], &[3, 2, 4][..]))"
}
```
```

--------------------------------

### Find Partition Point in a Slice

Source: https://docs.rs/three-d/latest/three_d/renderer/object/struct.Model.html

Returns the index of the first element for which the predicate returns false. The slice is assumed to be partitioned such that elements satisfying the predicate come before those that do not. This method performs a binary search.

```rust
let v = [1, 2, 3, 3, 5, 6, 7];
let i = v.partition_point(|&x| x < 5);

assert_eq!(i, 4);
assert!(v[..i].iter().all(|&x| x < 5));
assert!(v[i..].iter().all(|&x| !(x < 5)));
```

```rust
let a = [2, 4, 8];
assert_eq!(a.partition_point(|x| x < &100), a.len());
let a: [i32; 0] = [];
assert_eq!(a.partition_point(|x| x < &100), 0);
```

```rust
let mut s = vec![0, 1, 1, 1, 1, 2, 3, 5, 8, 13, 21, 34, 55];
let num = 42;
let idx = s.partition_point(|&x| x <= num);
s.insert(idx, num);
assert_eq!(s, [0, 1, 1, 1, 1, 2, 3, 5, 8, 13, 21, 34, 42, 55]);
```

--------------------------------

### copy_from_slice

Source: https://docs.rs/three-d/latest/three_d/renderer/object/struct.Model.html

Copies elements from a source slice into the destination slice using `memcpy`, requiring elements to implement `Copy`.

```APIDOC
## copy_from_slice

### Description
Copies all elements from `src` into `self`, using a memcpy. The length of `src` must be the same as `self`. If `T` does not implement `Copy`, use `clone_from_slice`.

### Method
`copy_from_slice(&mut self, src: &[T]) where T: Copy`

### Parameters
#### Path Parameters
- **src** (&[T]) - Required - The source slice to copy elements from.

### Panics
This function will panic if the two slices have different lengths.
```

--------------------------------

### Element Offset

Source: https://docs.rs/three-d/latest/three_d/renderer/object/struct.Model.html

Returns the index that a reference to an element points to within a slice. This is a nightly-only experimental API.

```APIDOC
## POST /api/slice/element_offset

### Description
Returns the index that an element reference points to. Returns `None` if `element` does not point to the start of an element within the slice. This method uses pointer arithmetic and does not compare elements.

### Method
POST

### Endpoint
/api/slice/element_offset

### Parameters
#### Request Body
- **slice** (array) - Required - The slice to check within.
- **element_ref** (string) - Required - A reference to the element whose offset is to be found.

### Request Example
```json
{
  "slice": [1, 7, 1, 1],
  "element_ref": "&nums[2]"
}
```

### Response
#### Success Response (200)
- **offset** (integer) - The index of the element, or `null` if the element reference is not aligned with the start of an element.

#### Response Example
```json
{
  "offset": 2
}
```
```

--------------------------------

### Finding Range of Elements with partition_point

Source: https://docs.rs/three-d/latest/three_d/renderer/object/struct.Model.html

Uses `partition_point` to find the range of elements equal to a specific value in a sorted slice. Useful for identifying all occurrences of an item.

```rust
let s = [0, 1, 1, 1, 1, 2, 3, 5, 8, 13, 21, 34, 55];

let low = s.partition_point(|x| x < &1);
assert_eq!(low, 1);
let high = s.partition_point(|x| x <= &1);
assert_eq!(high, 5);
let r = s.binary_search(&1);
assert!((low..high).contains(&r.unwrap()));

assert!(s[..low].iter().all(|&x| x < 1));
assert!(s[low..high].iter().all(|&x| x == 1));
assert!(s[high..].iter().all(|&x| x > 1));

// For something not found, the "range" of equal items is empty
assert_eq!(s.partition_point(|x| x < &11), 9);
assert_eq!(s.partition_point(|x| x <= &11), 9);
assert_eq!(s.binary_search(&11), Err(9));
```

--------------------------------

### Binary Search by Key on Slice of Tuples

Source: https://docs.rs/three-d/latest/three_d/renderer/object/struct.Model.html

Searches a slice of tuples based on a key extracted from each element. Assumes the slice is sorted by the extracted key.

```rust
let s = [(0, 0), (2, 1), (4, 1), (5, 1), (3, 1),
         (1, 2), (2, 3), (4, 5), (5, 8), (3, 13),
         (1, 21), (2, 34), (4, 55)];

assert_eq!(s.binary_search_by_key(&13, |&(a, b)| b),  Ok(9));
assert_eq!(s.binary_search_by_key(&4, |&(a, b)| b),   Err(7));
assert_eq!(s.binary_search_by_key(&100, |&(a, b)| b), Err(13));
let r = s.binary_search_by_key(&1, |&(a, b)| b);
assert!(match r { Ok(1..=4) => true, _ => false, });
```

--------------------------------

### Connect slice elements (deprecated)

Source: https://docs.rs/three-d/latest/three_d/renderer/object/struct.Model.html

Deprecated alias for the join method.

```rust
assert_eq!(["hello", "world"].connect(" "), "hello world");
assert_eq!([[1, 2], [3, 4]].connect(&0), [1, 2, 0, 3, 4]);
```

--------------------------------

### Slice Utility Methods

Source: https://docs.rs/three-d/latest/three_d/renderer/object/struct.Model.html

Methods available for slice manipulation including conversion to vectors, repetition, and flattening.

```APIDOC
## to_vec

### Description
Copies the slice into a new Vec.

### Method
fn to_vec(&self) -> Vec<T>

## to_vec_in

### Description
Copies the slice into a new Vec using a specific allocator.

### Method
fn to_vec_in<A>(&self, alloc: A) -> Vec<T, A>

## repeat

### Description
Creates a vector by copying a slice n times.

### Method
fn repeat(&self, n: usize) -> Vec<T>

## concat

### Description
Flattens a slice of T into a single value.

### Method
fn concat<Item>(&self) -> <[T] as Concat<Item>>::Output

## join

### Description
Flattens a slice of T into a single value, placing a given separator between each element.

### Method
fn join<Separator>(&self, sep: Separator) -> <[T] as Join<Separator>>::Output
```

--------------------------------

### Split Slice into SIMD and Scalar Parts

Source: https://docs.rs/three-d/latest/three_d/renderer/object/struct.Model.html

Splits a slice into a prefix, a middle section of aligned SIMD types, and a suffix. This is a safe wrapper around `slice::align_to` and requires nightly Rust with the `portable_simd` feature.

```rust
#![feature(portable_simd)]
use core::simd::prelude::*;

let short = &[1, 2, 3];
let (prefix, middle, suffix) = short.as_simd::<4>();
assert_eq!(middle, []); // Not enough elements for anything in the middle

// They might be split in any possible way between prefix and suffix
let it = prefix.iter().chain(suffix).copied();
assert_eq!(it.collect::<Vec<_>>(), vec![1, 2, 3]);

fn basic_simd_sum(x: &[f32]) -> f32 {
    use std::ops::Add;
    let (prefix, middle, suffix) = x.as_simd();
    let sums = f32x4::from_array([
        prefix.iter().copied().sum(),
        0.0,
        0.0,
        suffix.iter().copied().sum(),
    ]);
    let sums = middle.iter().copied().fold(sums, f32x4::add);
    sums.reduce_sum()
}

let numbers: Vec<f32> = (1..101).map(|x| x as _).collect();
assert_eq!(basic_simd_sum(&numbers[1..99]), 4949.0);

```

--------------------------------

### pub fn sort_by<F>(&mut self, compare: F)

Source: https://docs.rs/three-d/latest/three_d/renderer/object/struct.Model.html

Sorts the slice with a comparator function.

```APIDOC
## sort_by

### Description
Sorts the slice using a comparator function. This implementation uses driftsort, combining quicksort and mergesort characteristics.

### Parameters
#### Request Body
- **compare** (FnMut(&T, &T) -> Ordering) - Required - Comparator function defining the total order.

### Request Example
```rust
let mut v = [4, -5, 1, -3, 2];
v.sort_by(|a, b| a.cmp(b));
```
```

--------------------------------

### partition_point

Source: https://docs.rs/three-d/latest/three_d/renderer/object/struct.Model.html

Returns the index of the partition point according to a given predicate.

```APIDOC
## partition_point

### Description
Returns the index of the partition point according to the given predicate (the index of the first element of the second partition). The slice is assumed to be partitioned according to the given predicate.

### Parameters
- **pred** (FnMut(&T) -> bool) - Required - The predicate function to test elements against.

### Response
- **usize** - The index of the first element of the second partition.
```

--------------------------------

### Binary Search on a Sorted Slice

Source: https://docs.rs/three-d/latest/three_d/renderer/object/struct.Model.html

Performs binary search on a sorted slice to find elements or determine insertion points. Handles cases where elements are not found.

```rust
let s = [0, 1, 1, 1, 1, 2, 3, 5, 8, 13, 21, 34, 55];

assert_eq!(s.binary_search(&13),  Ok(9));
assert_eq!(s.binary_search(&4),   Err(7));
assert_eq!(s.binary_search(&100), Err(13));
let r = s.binary_search(&1);
assert!(match r { Ok(1..=4) => true, _ => false, });
```

--------------------------------

### Model Trait Implementations

Source: https://docs.rs/three-d/latest/three_d/renderer/object/struct.Model.html

Trait implementations for the Model struct, including dereferencing and iteration capabilities.

```APIDOC
## Deref / DerefMut

### Description
Allows the Model to be dereferenced into a vector of ModelParts.

### Methods
- fn deref(&self) -> &Self::Target
- fn deref_mut(&mut self) -> &mut Self::Target

## IntoIterator

### Description
Allows the Model to be iterated over as a collection of objects.

### Method
fn into_iter(self) -> Self::IntoIter
```

--------------------------------

### binary_search_by_key

Source: https://docs.rs/three-d/latest/three_d/renderer/object/struct.Model.html

Performs a binary search by extracting a key from each element using a provided function. Assumes the slice is sorted by this key.

```APIDOC
## binary_search_by_key

### Description
Binary searches a slice by applying a key extraction function to each element. Assumes the slice is sorted by the extracted key.

### Method
`binary_search_by_key`

### Endpoint
N/A (Method on slice)

### Parameters
- **b** (&B) - The key to search for.
- **f** (FnMut(&'a T) -> B) - The key extraction function.

### Request Example
```rust
let s = [(0, 0), (2, 1), (4, 1), (5, 1), (3, 1),
         (1, 2), (2, 3), (4, 5), (5, 8), (3, 13),
         (1, 21), (2, 34), (4, 55)];

assert_eq!(s.binary_search_by_key(&13, |&(a, b)| b),  Ok(9));
assert_eq!(s.binary_search_by_key(&4, |&(a, b)| b),   Err(7));
```

### Response
#### Success Response (Ok)
- **index** (usize) - The index of a matching element.
#### Error Response (Err)
- **insertion_point** (usize) - The index where a matching element could be inserted.

#### Response Example
```json
// For Ok(9)
9

// For Err(7)
7
```
```

--------------------------------

### Binary Search with Custom Comparator

Source: https://docs.rs/three-d/latest/three_d/renderer/object/struct.Model.html

Performs binary search on a slice using a custom comparison function. This is useful when the sorting criteria are not directly comparable or require custom logic.

```rust
let s = [0, 1, 1, 1, 1, 2, 3, 5, 8, 13, 21, 34, 55];

let seek = 13;
assert_eq!(s.binary_search_by(|probe| probe.cmp(&seek)), Ok(9));
let seek = 4;
assert_eq!(s.binary_search_by(|probe| probe.cmp(&seek)), Err(7));
let seek = 100;
assert_eq!(s.binary_search_by(|probe| probe.cmp(&seek)), Err(13));
let seek = 1;
let r = s.binary_search_by(|probe| probe.cmp(&seek));
assert!(match r { Ok(1..=4) => true, _ => false, });
```

--------------------------------

### TryFrom Trait

Source: https://docs.rs/three-d/latest/three_d/renderer/object/struct.Model.html

Defines the interface for types that can be created from another type, potentially failing.

```APIDOC
## impl<T, U> TryFrom<U> for T

### Description
Provides a way to perform a fallible conversion from type U to type T.

### Associated Types
- **Error** (Infallible) - The type returned in the event of a conversion error.

### Methods
- **try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>** - Performs the conversion.
```

--------------------------------

### Clone Slice from Slice

Source: https://docs.rs/three-d/latest/three_d/renderer/object/struct.Model.html

Copies elements from a source slice to a destination slice. Both slices must have the same length. Requires elements to implement `Clone`.

```rust
let src = [1, 2, 3, 4];
let mut dst = [0, 0];

// Because the slices have to be the same length,
// we slice the source slice from four elements
// to two. It will panic if we don't do this.
dst.clone_from_slice(&src[2..]);

assert_eq!(src, [1, 2, 3, 4]);
assert_eq!(dst, [3, 4]);

```

```rust
let mut slice = [1, 2, 3, 4, 5];

slice[..2].clone_from_slice(&slice[3..]); // compile fail!

```

```rust
let mut slice = [1, 2, 3, 4, 5];

{
    let (left, right) = slice.split_at_mut(2);
    left.clone_from_slice(&right[1..]);
}

assert_eq!(slice, [4, 5, 3, 4, 5]);

```

--------------------------------

### trim_prefix

Source: https://docs.rs/three-d/latest/three_d/renderer/object/struct.Model.html

Removes an optional prefix from a slice.

```APIDOC
## trim_prefix

### Description
Nightly-only experimental API. Returns a subslice with the optional prefix removed. If the slice starts with `prefix`, returns the subslice after the prefix. If `prefix` is empty or the slice does not start with `prefix`, returns the original slice.

### Parameters
- **prefix** (SlicePattern) - Required - The pattern to remove from the start.

### Response
- **&[T]** - The resulting subslice or the original slice.
```

--------------------------------

### Handle Out-of-Bounds Range with split_off

Source: https://docs.rs/three-d/latest/three_d/renderer/object/struct.Model.html

Demonstrates that `split_off` returns `None` and does not modify the slice when the provided range is out of bounds. It also shows a successful split when the range is valid.

```rust
let mut slice: &[_] = &['a', 'b', 'c', 'd'];

assert_eq!(None, slice.split_off(5..));
assert_eq!(None, slice.split_off(..5));
assert_eq!(None, slice.split_off(..=4));
let expected: &[char] = &['a', 'b', 'c', 'd'];
assert_eq!(Some(expected), slice.split_off(..4));
```

--------------------------------

### pub fn sort_by_cached_key<K, F>(&mut self, f: F)

Source: https://docs.rs/three-d/latest/three_d/renderer/object/struct.Model.html

Sorts the slice using a key extraction function, caching the keys to minimize function calls.

```APIDOC
## sort_by_cached_key

### Description
Sorts the slice using a key extraction function, caching the results to ensure the function is called at most once per element. This is a stable sort with O(m * n + n * log(n)) worst-case complexity.

### Parameters
#### Request Body
- **f** (FnMut(&T) -> K) - Required - Key extraction function where K implements Ord.
```

--------------------------------

### binary_search

Source: https://docs.rs/three-d/latest/three_d/renderer/object/struct.Model.html

Performs a binary search on a sorted slice to find an element. Returns Ok(index) if found, or Err(insertion_point) if not found.

```APIDOC
## binary_search

### Description
Performs a binary search on a sorted slice. If the value is found, returns `Ok` with the index. If not found, returns `Err` with the index where it could be inserted.

### Method
`binary_search`

### Endpoint
N/A (Method on slice)

### Parameters
None directly on the method, operates on the slice itself.

### Request Example
```rust
let s = [0, 1, 1, 1, 1, 2, 3, 5, 8, 13, 21, 34, 55];

assert_eq!(s.binary_search(&13),  Ok(9));
assert_eq!(s.binary_search(&4),   Err(7));
assert_eq!(s.binary_search(&100), Err(13));
let r = s.binary_search(&1);
assert!(match r { Ok(1..=4) => true, _ => false, });
```

### Response
#### Success Response (Ok)
- **index** (usize) - The index of the found element.
#### Error Response (Err)
- **insertion_point** (usize) - The index where the element could be inserted to maintain order.

#### Response Example
```json
// For Ok(9)
9

// For Err(7)
7
```
```

--------------------------------

### pub fn sort_by

Source: https://docs.rs/three-d/latest/three_d/renderer/object/struct.Model.html

Sorts the slice in ascending order using a custom comparison function, preserving the initial order of equal elements.

```APIDOC
## pub fn sort_by<F>(&mut self, compare: F)

### Description
Sorts the slice using a provided comparison function. This is a stable sort with O(n * log(n)) worst-case complexity.

### Parameters
- **compare** (F) - Required - A closure that takes two references to elements and returns an Ordering.
```

--------------------------------

### binary_search

Source: https://docs.rs/three-d/latest/three_d/renderer/object/struct.Model.html

Performs a binary search on a sorted slice.

```APIDOC
## binary_search

### Description
Binary searches this slice for a given element. If the slice is not sorted, the returned result is unspecified. If found, returns `Result::Ok` with the index. If not found, returns `Result::Err` with the insertion index.

### Parameters
- **x** (T) - Required - The element to search for.

### Response
- **Result<usize, usize>** - Ok(index) if found, Err(index) if not found.
```

--------------------------------

### as_simd_mut

Source: https://docs.rs/three-d/latest/three_d/renderer/object/struct.Model.html

Splits a mutable slice into a mutable prefix, a middle of aligned SIMD types, and a mutable suffix.

```APIDOC
## as_simd_mut<const LANES: usize>(&mut self)

### Description
Splits a mutable slice into a mutable prefix, a middle of aligned SIMD types, and a mutable suffix. This is a safe wrapper around slice::align_to_mut.

### Parameters
#### Path Parameters
- **LANES** (usize) - Required - The number of lanes for the SIMD type.

### Panics
This will panic if the size of the SIMD type is different from LANES times that of the scalar.
```

--------------------------------

### clone_from_slice

Source: https://docs.rs/three-d/latest/three_d/renderer/object/struct.Model.html

Copies elements from a source slice into the destination slice, requiring elements to implement `Clone`.

```APIDOC
## clone_from_slice

### Description
Copies the elements from `src` into `self`. The length of `src` must be the same as `self`.

### Method
`clone_from_slice(&mut self, src: &[T]) where T: Clone`

### Parameters
#### Path Parameters
- **src** (&[T]) - Required - The source slice to copy elements from.

### Panics
This function will panic if the two slices have different lengths.

### Examples
Cloning two elements from a slice into another:
```rust
let src = [1, 2, 3, 4];
let mut dst = [0, 0];

// Because the slices have to be the same length,
// we slice the source slice from four elements
// to two. It will panic if we don't do this.
dst.clone_from_slice(&src[2..]);

assert_eq!(src, [1, 2, 3, 4]);
assert_eq!(dst, [3, 4]);
```

To work around Rust's borrowing rules when copying within the same slice, use `split_at_mut`:
```rust
let mut slice = [1, 2, 3, 4, 5];

{
    let (left, right) = slice.split_at_mut(2);
    left.clone_from_slice(&right[1..]);
}

assert_eq!(slice, [4, 5, 3, 4, 5]);
```
```

--------------------------------

### Copy slice to a new Vector with allocator

Source: https://docs.rs/three-d/latest/three_d/renderer/object/struct.Model.html

Creates a new Vec using a specific allocator. Requires the allocator_api feature.

```rust
#![feature(allocator_api)]

use std::alloc::System;

let s = [10, 40, 30];
let x = s.to_vec_in(System);
// Here, `s` and `x` can be modified independently.
```

--------------------------------

### Reorder slice with select_nth_unstable_by_key

Source: https://docs.rs/three-d/latest/three_d/renderer/object/struct.Model.html

Reorders a slice using a key extraction function to partition elements based on their keys.

```rust
let mut v = [-5i32, 4, 1, -3, 2];

// Find the items `<=` to the absolute median, the absolute median itself, and the items
// `>=` to it.
let (lesser, median, greater) = v.select_nth_unstable_by_key(2, |a| a.abs());

assert!(lesser == [1, 2] || lesser == [2, 1]);
assert_eq!(median, &mut -3);
assert!(greater == [4, -5] || greater == [-5, 4]);

// We are only guaranteed the slice will be one of the following, based on the way we sort
// about the specified index.
assert!(v == [1, 2, -3, 4, -5] ||
        v == [1, 2, -3, -5, 4] ||
        v == [2, 1, -3, 4, -5] ||
        v == [2, 1, -3, -5, 4]);
```
Tokens:
Raw