Leptos

https://docs.rs/leptos/latest/
Admin
Leptos is a full-stack framework for building web applications in Rust, supporting single-page apps...
Tokens:16,728,970
Snippets:121,054
Trust Score:9.7
Update:5 months ago
Show doc for...
Tokens:
Raw
### RangeBounds start_bound Example

Source: https://docs.rs/leptos/latest/leptos/server_fn/inventory/core/ops/trait.RangeBounds.html

Demonstrates how to get the start bound of a range using the start_bound() method. Works with unbounded and included start bounds.

```rust
use std::ops.Bound::*;
use std::ops.RangeBounds;

assert_eq!((..10).start_bound(), Unbounded);
assert_eq!((3..10).start_bound(), Included(&3));
```

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

### ReadSignal Example

Source: https://docs.rs/leptos/latest/leptos/reactive/signal/struct.ReadSignal.html

A basic example demonstrating the usage of `get()` and `read()` methods on a ReadSignal.

```APIDOC
## Example Usage

```rust
let (count, set_count) = signal(0);

// calling .get() clones and returns the value
assert_eq!(count.get(), 0);

// calling .read() accesses the value by reference
assert_eq!(count.read(), 0);
```
```

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

### Examples for Last

Source: https://docs.rs/leptos/latest/leptos/server_fn/inventory/core/index/struct.Last.html

Demonstrates how to use the `Last` struct with slice indexing and the `get` method.

```APIDOC
## §Examples

```rust
#![feature(sliceindex_wrappers)]
#![feature(slice_index_methods)]

use core::index::Last;
use core::slice::SliceIndex;

let s = &[0, 1, 2, 3];

assert_eq!(&3, &s[Last]);
assert_eq!(None, Last.get(&[] as &[usize]));

```
```

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

### RangeFrom Examples

Source: https://docs.rs/leptos/latest/leptos/server_fn/inventory/core/range/struct.RangeFrom.html

Demonstrates the creation and usage of RangeFrom, including conversion from range syntax and iteration. Note that the `start..` syntax for constructing RangeFrom is planned for a future Rust edition.

```rust
use core::range::RangeFrom;

assert_eq!(RangeFrom::from(2..), core::range::RangeFrom { start: 2 });
assert_eq!(2 + 3 + 4, RangeFrom::from(2..).into_iter().take(3).sum());
```

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

### Range Endpoint Examples

Source: https://docs.rs/leptos/latest/leptos/server_fn/inventory/core/ops/enum.Bound.html

Demonstrates how to use the `start_bound` and `end_bound` methods to get the Bound variants for different range syntaxes.

```rust
use std::ops::Bound::*;
use std::ops::RangeBounds;

assert_eq!((..100).start_bound(), Unbounded);
assert_eq!((1..12).start_bound(), Included(&1));
assert_eq!((1..12).end_bound(), Excluded(&12));
```

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

### Basic Usage Example

Source: https://docs.rs/leptos/latest/leptos/server_fn/inventory/core/prelude/rust_2021/macro.format_args.html

A simple example demonstrating the use of format_args! with std::fmt::format.

```APIDOC
## §Examples
```rust
use std::fmt;

let s = fmt::format(format_args!("hello {}", "world"));
assert_eq!(s, format!("hello {}", "world"));
```
```

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

### Getting the Start Bound of a RangeInclusive

Source: https://docs.rs/leptos/latest/leptos/server_fn/inventory/core/ops/struct.RangeInclusive.html

Demonstrates how to retrieve the lower bound (inclusive start) of a `RangeInclusive` using the `start()` method.

```rust
assert_eq!((3..=5).start(), &3);
```

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

### NonZero<u32> Examples

Source: https://docs.rs/leptos/latest/leptos/server_fn/inventory/core/num/type.NonZeroU32.html

Demonstrates how to create and use NonZero<u32> instances, including parsing from strings with radix and handling errors.

```APIDOC
## Examples

### Parsing from String with Radix

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

assert_eq!(NonZero::<u32>::from_str_radix("A", 16), Ok(NonZero::new(10)?));
```

### Trailing Space Returns Error

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

assert!(NonZero::<u32>::from_str_radix("1 ", 10).is_err());
```
```

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

### Get minimum alignment of i32

Source: https://docs.rs/leptos/latest/leptos/server_fn/inventory/core/mem/fn.min_align_of.html

Use `std::mem::min_align_of` to get the minimum alignment of a type. This example shows how to get the minimum alignment for an `i32`.

```rust
use std::mem;

assert_eq!(4, mem::min_align_of::<i32>());
```

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

### TryFrom Usage Example with i64 to i32

Source: https://docs.rs/leptos/latest/leptos/server_fn/inventory/core/convert/trait.TryFrom.html

Illustrates the usage of TryFrom for converting an i64 to an i32, showing both successful and error cases.

```APIDOC
## Usage Example

```rust
let big_number = 1_000_000_000_000i64;

// Returns an error because `big_number` is too big to
// fit in an `i32`.
let try_smaller_number = i32::try_from(big_number);
assert!(try_smaller_number.is_err());

// Returns `Ok(3)`.
let try_successful_smaller_number = i32::try_from(3);
assert!(try_successful_smaller_number.is_ok());
```
```

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

### type_name Example

Source: https://docs.rs/leptos/latest/leptos/server_fn/inventory/core/any/fn.type_name.html

An example demonstrating the usage of `std::any::type_name` to get the string representation of `Option<String>`.

```APIDOC
## Example

```rust
assert_eq!(
    std::any::type_name::<Option<String>>(),
    "core::option::Option<alloc::string::String>",
);
```
```

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

### Example of build_hasher

Source: https://docs.rs/leptos/latest/leptos/server_fn/inventory/core/hash/trait.BuildHasher.html

Illustrates creating a new hasher instance using the `build_hasher` method.

```APIDOC
##### §Examples
```rust
use std::hash::{BuildHasher, RandomState};

let s = RandomState::new();
let new_s = s.build_hasher();
```
```

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

### Get size of a dynamically known value (slice)

Source: https://docs.rs/leptos/latest/leptos/server_fn/inventory/core/mem/fn.size_of_val.html

Use `size_of_val` to get the size of a slice, which has a dynamically known size. This example shows getting the size of a byte slice.

```rust
let x: [u8; 13] = [0; 13];
let y: &[u8] = &x;
assert_eq!(13, size_of_val(y));
```

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

### RangeFrom Syntax and Usage

Source: https://docs.rs/leptos/latest/leptos/server_fn/inventory/core/ops/struct.RangeFrom.html

Demonstrates the `start..` syntax for creating a RangeFrom and its use in summing elements.

```rust
assert_eq!((2..), std::ops::RangeFrom { start: 2 });
assert_eq!(2 + 3 + 4, (2..).take(3).sum());
```

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

### Basic Usage of format_args!

Source: https://docs.rs/leptos/latest/leptos/server_fn/inventory/core/macro.format_args.html

A simple example showing how to use format_args! to create a formatted string and comparing it with the standard format! macro.

```rust
use std::fmt;

let s = fmt::format(format_args!("hello {}", "world"));
assert_eq!(s, format!("hello {}", "world"));
```

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

### NonZero<usize> bit_width Examples

Source: https://docs.rs/leptos/latest/leptos/server_fn/inventory/core/num/type.NonZeroUsize.html

Examples showing how to get the minimum number of bits required to represent a NonZero<usize> value.

```rust
assert_eq!(NonZero::<usize>::MIN.bit_width(), NonZero::new(1)?);
```

```rust
assert_eq!(NonZero::<usize>::new(0b111)?.bit_width(), NonZero::new(3)?);
```

```rust
assert_eq!(NonZero::<usize>::new(0b1110)?.bit_width(), NonZero::new(4)?);
```

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

### Get alignment of i32

Source: https://docs.rs/leptos/latest/leptos/server_fn/inventory/core/mem/fn.align_of_val_raw.html

This example demonstrates how to use `align_of_val_raw` to get the alignment of an `i32`. This function requires the `layout_for_ptr` feature and is unsafe.

```rust
#![feature(layout_for_ptr)]
use std::mem;

assert_eq!(4, unsafe { mem::align_of_val_raw(&5i32) });
```

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

### start_sharing Method

Source: https://docs.rs/leptos/latest/leptos/server_fn/rkyv/ser/sharing/trait.Sharing.html

Initiates the sharing process for a value identified by its address. Returns the current sharing state.

```rust
fn start_sharing(&mut self, address: usize) -> SharingState;
```

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

### TransitionProps Usage Example

Source: https://docs.rs/leptos/latest/leptos/suspense/struct.TransitionProps.html

An example demonstrating how to use the `Transition` component with `TransitionProps`, including loading resources and handling fallback UI.

```APIDOC
```rust
async fn fetch_cats(how_many: u32) -> Vec<String> { vec![] }

let (cat_count, set_cat_count) = signal::<u32>(1);

let cats = Resource::new(move || cat_count.get(), |count| fetch_cats(count));

view! {
  <div>
    <Transition fallback=move || view! { <p>"Loading (Suspense Fallback)..."</p> }>
      // you can access a resource synchronously
      {move || {
          cats.get().map(|data| {
            data
              .into_iter()
              .map(|src| {
                  view! {
                    <img src={src}/>
                  }
              })
              .collect_view()
          })
        }
      }
      // or you can use `Suspend` to read resources asynchronously
      {move || Suspend::new(async move {
        cats.await
              .into_iter()
              .map(|src| {
                  view! {
                    <img src={src}/>
                  }
              })
              .collect_view()
      })}
    </Transition>
  </div>
}
```
```

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

### Initialization and Utility Methods

Source: https://docs.rs/leptos/latest/leptos/tachys/svg/struct.FeTurbulence.html

Methods for initializing instances and utility functions.

```APIDOC
## `initialize_from_function` Method

### Description
Create an instance of this type from an initialization function.

### Signature
`fn initialize_from_function(f: fn() -> T) -> T`

### Associated Implementation
- `impl<T> InitializeFromFunction<T> for T`
```

```APIDOC
## `instrument` and `in_current_span` Methods

### Description
Instruments this type with the provided `Span` or the current `Span`, returning an `Instrumented` wrapper.

### Signatures
- `fn instrument(self, span: Span) -> Instrumented<Self>`
- `fn in_current_span(self) -> Instrumented<Self>`

### Associated Implementation
- `impl<T> Instrument for T`
```

```APIDOC
## `into` Method

### Description
Calls `U::from(self)`. This conversion is whatever the implementation of `From<T> for U` chooses to do.

### Signature
`fn into(self) -> U`

### Associated Implementation
- `impl<T, U> Into<U> for T where U: From<T>`
```

```APIDOC
## `into_either` and `into_either_with` Methods

### Description
Converts `self` into a `Left` or `Right` variant of `Either<Self, Self>` based on a boolean flag or a closure.

### Signatures
- `fn into_either(self, into_left: bool) -> Either<Self, Self>`
- `fn into_either_with<F>(self, into_left: F) -> Either<Self, Self> where F: FnOnce(&Self) -> bool`

### Associated Implementation
- `impl<T> IntoEither for T`
```

```APIDOC
## `into_reactive_value` Method

### Description
Converts `self` into a `T`.

### Signature
`fn into_reactive_value(self) -> T`

### Associated Implementation
- `impl<T, I> IntoReactiveValue<T, __IntoReactiveValueMarkerBaseCase> for I where I: Into<T>`
```

```APIDOC
## `layout_raw` Method

### Description
Returns the layout of the type.

### Signature
`fn layout_raw(_: <T as Pointee>::Metadata) -> Result<Layout, LayoutError>`

### Associated Implementation
- `impl<T> LayoutRaw for T`
```

```APIDOC
## `is_niched` and `resolve_niched` Methods

### Description
Methods related to niching, checking if a value is niched and resolving niched data.

### Signatures
- `unsafe fn is_niched(niched: *const NichedOption<T, N1>) -> bool`
- `fn resolve_niched(out: Place<NichedOption<T, N1>>)`

### Associated Implementation
- `impl<T, N1, N2> Niching<NichedOption<T, N1>> for N2 where T: SharedNiching<N1, N2>, N1: Niching<T>, N2: Niching<T>`
```

```APIDOC
## `Metadata` Type Alias

### Description
The metadata type for pointers and references to this type.

### Associated Implementation
- `impl<T> Pointee for T`
```

```APIDOC
## `Output` Type Alias

### Description
Should always be `Self`.

### Associated Implementation
- `impl<T> Same for T`
```

```APIDOC
## `ser_key` Method

### Description
Serializes the key to a unique string.

### Signature
`fn ser_key(&self) -> String`

### Associated Implementation
- `impl<T> SerializableKey for T`
```

```APIDOC
## `spawn` Method

### Description
Spawn the value into the dioxus runtime if it is an async block.

### Signature
`fn spawn(self) -> Ret`

### Associated Implementation
- `impl<Ret> SpawnIfAsync<(), Ret> for Ret`
```

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

### Panics when range is out of bounds (start > end)

Source: https://docs.rs/leptos/latest/leptos/server_fn/inventory/core/slice/fn.range.html

This example shows a case where the `range` function will panic because the start of the provided range is greater than its end, similar to how `Index::index` would behave.

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

use std::slice;

let _ = slice::range(2..1, ..3);
```

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

### Box::from_raw with Global Allocator Example

Source: https://docs.rs/leptos/latest/leptos/children/type.Children.html

Shows how to manually create a `Box` from scratch using the global allocator and a raw pointer. This requires careful handling of memory allocation and deallocation.

```rust
use std::alloc::{alloc, Layout};

unsafe {
    let ptr = alloc(Layout::new::<i32>()) as *mut i32;
    // In general .write is required to avoid attempting to destruct
    // the (uninitialized) previous contents of `ptr`, though for this
    // simple example `*ptr = 5` would have worked as well.
    ptr.write(5);
    let x = Box::from_raw(ptr);
}
```

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

### RangeToInclusive start_bound and end_bound

Source: https://docs.rs/leptos/latest/leptos/server_fn/inventory/core/range/struct.RangeToInclusive.html

Shows how to get the start and end bounds of a RangeToInclusive when it implements RangeBounds.

```rust
/// Start index bound. Read more
```

```rust
/// End index bound. Read more
```

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

### Example: HashMap length

Source: https://docs.rs/leptos/latest/leptos/server_fn/serde_lite/struct.Map.html

Shows how to get the number of elements in a HashMap using the `len()` method.

```rust
use std::collections::HashMap;

let mut a = HashMap::new();
assert_eq!(a.len(), 0);
a.insert(1, "a");
assert_eq!(a.len(), 1);
```

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

### Server Function Example

Source: https://docs.rs/leptos/latest/leptos/attr.server.html

An example demonstrating the usage of the `#[server]` macro with various named arguments.

```APIDOC
ⓘ```
#[server(
  name = SomeStructName,
  prefix = "/my_api",
  endpoint = "my_fn",
  input = Cbor,
  output = Json
  impl_from = true
)]
pub async fn my_wacky_server_fn(input: Vec<String>) -> Result<usize, ServerFnError> {
  todo!()
}
```
```

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

### ArcReadSignal Example Usage

Source: https://docs.rs/leptos/latest/leptos/reactive/signal/struct.ArcReadSignal.html

Demonstrates basic usage of ArcReadSignal, including getting and reading its value.

```APIDOC
## Example

```rust
let (count, set_count) = arc_signal(0);

// calling .get() clones and returns the value
assert_eq!(count.get(), 0);
// calling .read() accesses the value by reference
assert_eq!(count.read(), 0);
```
```

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

### BitXorAssign Example

Source: https://docs.rs/leptos/latest/leptos/server_fn/inventory/core/ops/trait.BitXorAssign.html

An example demonstrating how to implement and use the `BitXorAssign` trait for a custom struct.

```APIDOC
## §Examples
```rust
use std::ops::BitXorAssign;

#[derive(Debug, PartialEq)]
struct Personality {
    has_soul: bool,
    likes_knitting: bool,
}

impl BitXorAssign for Personality {
    fn bitxor_assign(&mut self, rhs: Self) {
        self.has_soul ^= rhs.has_soul;
        self.likes_knitting ^= rhs.likes_knitting;
    }
}

let mut personality = Personality { has_soul: false, likes_knitting: true };
personality ^= Personality { has_soul: true, likes_knitting: true };
assert_eq!(personality, Personality { has_soul: true, likes_knitting: false});
```
```

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

### RangeTo Example: Creating and Comparing

Source: https://docs.rs/leptos/latest/leptos/server_fn/inventory/core/ops/struct.RangeTo.html

Demonstrates how to create a RangeTo using the `..end` syntax and assert its equality with a manually constructed RangeTo.

```rust
assert_eq!((..5), std::ops::RangeTo { end: 5 });
```

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

### ReadSignal Example Usage

Source: https://docs.rs/leptos/latest/leptos/prelude/struct.ReadSignal.html

Demonstrates basic usage of ReadSignal's get() and read() methods.

```APIDOC
## Example

```rust
let (count, set_count) = signal(0);

// calling .get() clones and returns the value
assert_eq!(count.get(), 0);

// calling .read() accesses the value by reference
assert_eq!(count.read(), 0);
```
```

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

### Get Base Pointer

Source: https://docs.rs/leptos/latest/leptos/server_fn/rkyv/rel_ptr/type.RawRelPtrI64.html

Retrieves the base pointer of the relative pointer. This is the starting address for offset calculations.

```rust
pub fn base(&self) -> *const u8
```

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

### NonZero<i8> Examples

Source: https://docs.rs/leptos/latest/leptos/server_fn/inventory/core/num/type.NonZeroI8.html

Examples demonstrating the usage of NonZero<i8>, including parsing from a string radix and handling errors.

```APIDOC
## NonZero<i8> Examples

### Description
Examples demonstrating the usage of `NonZero<i8>`, including parsing from a string radix and handling errors.

### Code Examples

**Parsing with a valid radix:**
```rust
#![feature(nonzero_from_str_radix)]

assert_eq!(NonZero::<i8>::from_str_radix("A", 16), Ok(NonZero::new(10)?));
```

**Handling trailing space error:**
```rust
#![feature(nonzero_from_str_radix)]

assert!(NonZero::<i8>::from_str_radix("1 ", 10).is_err());
```
```

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

### Compile-time Creation Example

Source: https://docs.rs/leptos/latest/leptos/server_fn/inventory/core/num/type.NonZeroI8.html

Demonstrates how to create a `NonZeroI8` at compile time using `NonZeroI8::new` and `expect`.

```APIDOC
## §Compile-time creation
Since `Option::unwrap()` and `Option::expect()` are `const`, it is possible to define a new `NonZeroI8` at compile time via:

```rust
use std::num::NonZeroI8;

const TEN: NonZeroI8 = NonZeroI8::new(10).expect("ten is non-zero");
```
```

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

### Get Raw Base Pointer

Source: https://docs.rs/leptos/latest/leptos/server_fn/rkyv/rel_ptr/type.RawRelPtrI64.html

Retrieves the base pointer of a RawRelPtr. This is the starting address from which the offset is calculated.

```rust
pub fn base_raw(this: *mut RawRelPtr<O>) -> *mut u8
```

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

### Get Base Pointer

Source: https://docs.rs/leptos/latest/leptos/server_fn/rkyv/rel_ptr/type.RawRelPtrI32.html

Retrieves the base pointer for the relative pointer. This is the starting point for offset calculations.

```rust
pub fn base(&self) -> *const u8

```

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

### BuildHasher build_hasher Method Example

Source: https://docs.rs/leptos/latest/leptos/server_fn/inventory/core/hash/trait.BuildHasher.html

Shows a basic example of creating a new hasher instance using the build_hasher method from a RandomState.

```rust
use std::hash::{BuildHasher, RandomState};

let s = RandomState::new();
let new_s = s.build_hasher();
```

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

### Using a FnOnce parameter Example

Source: https://docs.rs/leptos/latest/leptos/server_fn/inventory/core/prelude/rust_2015/trait.FnOnce.html

An example demonstrating how to use a function that accepts a closure implementing FnOnce, highlighting that the closure can only be called once.

```APIDOC
## §Examples

### §Using a `FnOnce` parameter

```rust
fn consume_with_relish<F>(func: F)
    where F: FnOnce() -> String
{
    // `func` consumes its captured variables, so it cannot be run more
    // than once.
    println!("Consumed: {}", func());

    println!("Delicious!");

    // Attempting to invoke `func()` again will throw a `use of moved
    // value` error for `func`.
}

let x = String::from("x");
let consume_and_return_x = move || x;
consume_with_relish(consume_and_return_x);

// `consume_and_return_x` can no longer be invoked at this point
```
```

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

### Get Raw Base Pointer

Source: https://docs.rs/leptos/latest/leptos/server_fn/rkyv/rel_ptr/type.RawRelPtrI32.html

Retrieves the base pointer for a RawRelPtr. This is the starting point from which the offset is calculated.

```rust
pub fn base_raw(this: *mut RawRelPtr<O>) -> *mut u8

```

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

### ArrayWindows Usage Example

Source: https://docs.rs/leptos/latest/leptos/server_fn/inventory/core/slice/struct.ArrayWindows.html

Demonstrates how to create and use an ArrayWindows iterator to get overlapping windows from a slice.

```APIDOC
## ArrayWindows

leptos::server_fn::inventory::core::slice

A windowed iterator over a slice in overlapping chunks (`N` elements at a time), starting at the beginning of the slice.
This struct is created by the `array_windows` method on slices.

### Example
```rust
let slice = [0, 1, 2, 3];
let mut iter = slice.array_windows::<2>();
assert_eq!(iter.next(), Some(&[0, 1]));
assert_eq!(iter.next(), Some(&[1, 2]));
assert_eq!(iter.next(), Some(&[2, 3]));
assert_eq!(iter.next(), None);
```

### Iterator Methods

`ArrayWindows` implements the `Iterator` trait, providing methods such as:

*   `next()`: Advances the iterator and returns the next window.
*   `next_back()`: Removes and returns an element from the end of the iterator.
*   `nth(n)`: Returns the `n`th element of the iterator.
*   `last()`: Consumes the iterator, returning the last element.

It also implements `DoubleEndedIterator`, `ExactSizeIterator`, and other useful traits.
```

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

### f64::math::floor Example Usage

Source: https://docs.rs/leptos/latest/leptos/server_fn/inventory/core/f64/math/fn.floor.html

Example demonstrating the usage of the experimental `f64::math::floor` function. This example requires the `core_float_math` feature to be enabled.

```APIDOC
## §Examples

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

use core::f64;

let f = 3.7_f64;
let g = 3.0_f64;
let h = -3.7_f64;

assert_eq!(f64::math::floor(f), 3.0);
assert_eq!(f64::math::floor(g), 3.0);
assert_eq!(f64::math::floor(h), -4.0);
```
```

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

### NonZero<u64> Bit Width Examples

Source: https://docs.rs/leptos/latest/leptos/server_fn/inventory/core/num/type.NonZeroU64.html

Demonstrates how to get the bit width of a NonZero<u64> value.

```rust
assert_eq!(NonZero::<u64>::MIN.bit_width(), NonZero::new(1)?);
assert_eq!(NonZero::<u64>::new(0b111)?.bit_width(), NonZero::new(3)?);
assert_eq!(NonZero::<u64>::new(0b1110)?.bit_width(), NonZero::new(4)?);
```

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

### AsString Example Usage

Source: https://docs.rs/leptos/latest/leptos/server_fn/rkyv/with/struct.AsString.html

Demonstrates how to use the AsString wrapper with different types like OsString, PathBuf, and &str in a struct.

```APIDOC
## Example
```rust
use std::{ffi::OsString, path::PathBuf};

use rkyv::{with::AsString, Archive};

#[derive(Archive)]
struct Example<'a> {
    #[rkyv(with = AsString)]
    os_string: OsString,
    #[rkyv(with = AsString)]
    path: PathBuf,
    #[rkyv(with = AsString)]
    reference: &'a str,
}
```
```

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

### Examples of Select Usage

Source: https://docs.rs/leptos/latest/leptos/server_fn/inventory/core/simd/prelude/trait.Select.html

Illustrates how to use the `select` method with `Simd` and `Mask` types, including selection with a bitmask.

```APIDOC
## §Examples

### §Selecting values from `Simd`
```rust
let a = Simd::from_array([0, 1, 2, 3]);
let b = Simd::from_array([4, 5, 6, 7]);
let mask = Mask::<i32, 4>::from_array([true, false, false, true]);
let c = mask.select(a, b);
assert_eq!(c.to_array(), [0, 5, 6, 3]);
```

### §Selecting values from `Mask`
```rust
let a = Mask::<i32, 4>::from_array([true, true, false, false]);
let b = Mask::<i32, 4>::from_array([false, false, true, true]);
let mask = Mask::<i32, 4>::from_array([true, false, false, true]);
let c = mask.select(a, b);
assert_eq!(c.to_array(), [true, false, true, false]);
```

### §Selecting with a bitmask
```rust
let a = Mask::<i32, 4>::from_array([true, true, false, false]);
let b = Mask::<i32, 4>::from_array([false, false, true, true]);
let mask = 0b1001;
let c = mask.select(a, b);
assert_eq!(c.to_array(), [true, false, true, false]);
```
```

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

### NonZero<u128> Bit Width Examples

Source: https://docs.rs/leptos/latest/leptos/server_fn/inventory/core/num/type.NonZeroU128.html

Demonstrates how to get the bit width of a NonZero<u128> value.

```rust
assert_eq!(NonZero::<u128>::MIN.bit_width(), NonZero::new(1)?);
assert_eq!(NonZero::<u128>::new(0b111)?.bit_width(), NonZero::new(3)?);
assert_eq!(NonZero::<u128>::new(0b1110)?.bit_width(), NonZero::new(4)?);
```

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

### Example Usage of access_mut

Source: https://docs.rs/leptos/latest/leptos/server_fn/rkyv/api/low/fn.access_mut.html

This example demonstrates how to use `access_mut` to obtain mutable access to archived data. It serializes a struct, then uses `access_mut` to get a mutable reference to the archived version, allowing in-place modification.

```APIDOC
## §Example

```rust
use core::mem::MaybeUninit;

use rkyv::*
use rkyv::api::low::{to_bytes_in_with_alloc, access_mut};
use rkyv::rancor::Failure;
use rkyv::ser::{allocator::SubAllocator, writer::Buffer};
use rkyv::util::Align;
use rkyv::with::InlineAsBox;
use rkyv::munge::munge;

let mut output = Align([MaybeUninit::<u8>::uninit(); 256]);
let mut alloc = [MaybeUninit::<u8>::uninit(); 256];

#[derive(Archive, Serialize)]
struct Example {
    inner: i32,
}

let value = Example { inner: 42 };

let mut bytes = to_bytes_in_with_alloc::<_, _, Failure>(
    &value,
    Buffer::from(&mut *output),
    SubAllocator::new(&mut alloc),
)
.unwrap();

let mut archived = access_mut::<ArchivedExample, Failure>(
    &mut *bytes,
).unwrap();

// Because the access is mutable, we can mutate the archived data
munge!(let ArchivedExample { mut inner, .. } = archived);
assert_eq!(*inner, 42);
*inner = 12345.into();
assert_eq!(*inner, 12345);
```
```

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

### NonZero<u16> isolate_highest_one example

Source: https://docs.rs/leptos/latest/leptos/server_fn/inventory/core/num/type.NonZeroU16.html

Shows how to use isolate_highest_one to get a NonZero<u16> with only the most significant bit set.

```rust
let a = NonZero::<u16>::new(0b_01100100)?;
let b = NonZero::<u16>::new(0b_01000000)?;

assert_eq!(a.isolate_highest_one(), b);
```

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

### Example Usage of BuildHasher

Source: https://docs.rs/leptos/latest/leptos/server_fn/inventory/core/hash/trait.BuildHasher.html

Demonstrates how to use `RandomState` as a `BuildHasher` to create two identical hashers and verify their output.

```APIDOC
## §Examples
```rust
use std::hash::{BuildHasher, Hasher, RandomState};

let s = RandomState::new();
let mut hasher_1 = s.build_hasher();
let mut hasher_2 = s.build_hasher();

hasher_1.write_u32(8128);
hasher_2.write_u32(8128);

assert_eq!(hasher_1.finish(), hasher_2.finish());
```
```

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

### Compile-time Creation

Source: https://docs.rs/leptos/latest/leptos/server_fn/inventory/core/num/type.NonZeroU64.html

Demonstrates how to create a NonZeroU64 instance at compile time using `NonZeroU64::new` and `expect`.

```APIDOC
## §Compile-time creation

Since both `Option::unwrap()` and `Option::expect()` are `const`, it is possible to define a new `NonZeroU64` at compile time via:

```rust
use std::num::NonZeroU64;

const TEN: NonZeroU64 = NonZeroU64::new(10).expect("ten is non-zero");
```
```

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

### NonZeroU128::leading_zeros Example

Source: https://docs.rs/leptos/latest/leptos/server_fn/inventory/core/num/type.NonZeroU128.html

Illustrates how to get the number of leading zeros for a NonZeroU128, potentially optimized for non-zero values.

```rust
let n = NonZero::<u128>::new(u128::MAX)?;

assert_eq!(n.leading_zeros(), 0);
```

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

### Keyed View Example

Source: https://docs.rs/leptos/latest/leptos/tachys/view/keyed/struct.Keyed.html

This example demonstrates how to use the Keyed view to render a list of items. Each item has a unique key, allowing for efficient updates when the list changes.

```APIDOC
## Keyed View

### Description

The `Keyed` view is used to render a list of items where each item has a unique key. This allows for efficient updates when the list changes, as Leptos can track individual items by their keys.

### Usage

```rust
view! {
    <Keyed by=items key=|item| item.id>
        |item| {
            <div >{item.name}</div>
        }
    </Keyed>
}
```

### Parameters

- **`by`**: An iterable collection of items to render.
- **`key`**: A closure that takes an item and returns a unique key for that item. The key must implement `Eq` and `Hash`.

### Children

The `Keyed` view accepts a single child, which is a closure that takes an item and returns the view for that item.
```

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

### Getting a raw pointer to Rc data

Source: https://docs.rs/leptos/latest/leptos/tachys/html/event/type.SharedEventCallback.html

Provides an example of using `Rc::as_ptr` to get a raw pointer to the data inside an `Rc` without consuming the `Rc`. The pointer is valid as long as strong counts exist.

```rust
use std::rc::Rc;

let x = Rc::new(0);
let y = Rc::clone(&x);
let x_ptr = Rc::as_ptr(&x);
assert_eq!(x_ptr, Rc::as_ptr(&y));
assert_eq!(unsafe { *x_ptr }, 0);
```

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

### AtomicU32 fetch_sub Example

Source: https://docs.rs/leptos/latest/leptos/server_fn/inventory/core/sync/atomic/type.AtomicU32.html

Shows how to subtract a value from an AtomicU32 and get the previous value. This operation wraps around on overflow.

```rust
use std::sync::atomic::{AtomicU32, Ordering};

let foo = AtomicU32::new(20);
assert_eq!(foo.fetch_sub(10, Ordering::SeqCst), 20);
assert_eq!(foo.load(Ordering::SeqCst), 10);
```

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

### Server Function Example with Http Protocol

Source: https://docs.rs/leptos/latest/leptos/server_fn/struct.Http.html

Demonstrates using the Http protocol with GetUrl for input and Json for output. Requires input and output types to implement Serialize and Deserialize.

```rust
use serde::{Serialize, Deserialize};
use server_fn::{Http, ServerFnError, codec::{Json, GetUrl}};

#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct Message {
    user: String,
    message: String,
}

// The http protocol can be used on any server function that accepts and returns arguments that implement
// the [`IntoReq`] and [`FromRes`] traits.
//
// In this case, the input and output encodings are [`GetUrl`] and [`Json`], respectively which requires
// the items to implement [`IntoReq<GetUrl, ...>`] and [`FromRes<Json, ...>`]. Both of those implementations
// require the items to implement [`Serialize`] and [`Deserialize`].
#[server(protocol = Http<GetUrl, Json>)]
async fn echo_http(
    input: Message,
) -> Result<Message, ServerFnError> {
    Ok(input)
}
```

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

### WriteSignal Example Usage

Source: https://docs.rs/leptos/latest/leptos/prelude/struct.WriteSignal.html

Illustrates how to use WriteSignal's set, update, and write methods with examples.

```APIDOC
## WriteSignal Examples

### Setting a Value

```rust
let (count, set_count) = signal(0);
set_count.set(1);
assert_eq!(count.get(), 1);
```

### Updating a Value

```rust
let (count, set_count) = signal(0);
set_count.update(|count: &mut i32| *count += 1);
assert_eq!(count.get(), 2);
```

### Mutating with a Write Guard

```rust
let (count, set_count) = signal(0);
*set_count.write() += 1;
assert_eq!(count.get(), 3);
```
```

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

### UnsafePinned Example Usage

Source: https://docs.rs/leptos/latest/leptos/server_fn/inventory/core/pin/struct.UnsafePinned.html

Demonstrates the usage of `UnsafePinned` with `get` and `get_mut_unchecked` for reading and writing values. Requires the `unsafe_pinned` feature.

```rust
#![feature(unsafe_pinned)]
use std::pin::UnsafePinned;

unsafe {
    let mut x = UnsafePinned::new(0);
    let ptr = x.get();
    x.get_mut_unchecked().write(1);
    assert_eq!(ptr.read(), 1);
}
```

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

### Experimental provide Method Example

Source: https://docs.rs/leptos/latest/leptos/server_fn/inventory/core/error/trait.Error.html

Demonstrates the experimental `provide` method for type-based access to error context, requiring nightly Rust.

```rust
#![feature(error_generic_member_access)]
use core::fmt;
use core::error::{request_ref, Request};

#[derive(Debug)]
enum MyLittleTeaPot {
    Empty,
}

#[derive(Debug)]
struct MyBacktrace {
    // ...
}

impl MyBacktrace {
    fn new() -> MyBacktrace {
        // ...
    }
}

#[derive(Debug)]
struct Error {
    backtrace: MyBacktrace,
}

impl fmt::Display for Error {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        write!(f, "Example Error")
    }
}

impl std::error::Error for Error {
    fn provide<'a>(&'a self, request: &mut Request<'a>) {
        request
            .provide_ref::<MyBacktrace>(&self.backtrace);
    }
}

fn main() {
    let backtrace = MyBacktrace::new();
    let error = Error { backtrace };
    let dyn_error = &error as &dyn std::error::Error;
    let backtrace_ref = request_ref::<MyBacktrace>(dyn_error).unwrap();

    assert!(core::ptr::eq(&error.backtrace, backtrace_ref));
    assert!(request_ref::<MyLittleTeaPot>(dyn_error).is_none());
}
```

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

### Example of using access_unchecked_mut

Source: https://docs.rs/leptos/latest/leptos/server_fn/rkyv/fn.access_unchecked_mut.html

Demonstrates how to use `access_unchecked_mut` to get mutable access to archived data and then mutate it. This example serializes a struct, accesses it mutably using `access_unchecked_mut`, asserts its initial values, mutates a field, and asserts the new value.

```rust
use rkyv::{
    to_bytes,
    access_unchecked_mut,
    util::Align,
    munge::munge,
    Archive,
    Serialize,
    Deserialize,
    rancor::Error,
};

#[derive(Archive, Serialize, Deserialize)]
struct Example {
    name: String,
    value: i32,
}

let value = Example {
    name: "pi".to_string(),
    value: 31415926,
};

let mut bytes = to_bytes::<Error>(&value).unwrap();

let mut archived = unsafe {
    access_unchecked_mut::<ArchivedExample>(&mut *bytes)
};
assert_eq!(archived.name, "pi");
assert_eq!(archived.value, 31415926);

// Because the access is mutable, we can mutate the archived data
munge!(let ArchivedExample { mut value, .. } = archived);
assert_eq!(*value, 31415926);
*value = 12345.into();
assert_eq!(*value, 12345);

```

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

### Simd::extract Example

Source: https://docs.rs/leptos/latest/leptos/server_fn/inventory/core/simd/prelude/type.f32x32.html

Extracts a sub-vector from a SIMD vector, starting at a specified index and with a specified length. This is a nightly-only experimental API.

```rust
let x = u32x4::from_array([0, 1, 2, 3]);
assert_eq!(x.extract::<1, 2>().to_array(), [1, 2]);
```

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

### as_octets() Method Example

Source: https://docs.rs/leptos/latest/leptos/server_fn/inventory/core/net/enum.IpAddr.html

Shows how to get the eight-bit integers of an IP address using the `as_octets` method. This is a nightly-only experimental API.

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

use std::net::{Ipv4Addr, Ipv6Addr, IpAddr};

assert_eq!(IpAddr::V4(Ipv4Addr::LOCALHOST).as_octets(), &[127, 0, 0, 1]);
assert_eq!(IpAddr::V6(Ipv6Addr::LOCALHOST).as_octets(),
           &[0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1])
```

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

### Example file content for include! macro

Source: https://docs.rs/leptos/latest/leptos/server_fn/inventory/core/macro.include.html

This is an example of a file that can be included using the `include!` macro. The content must be valid Rust syntax that fits the context where `include!` is used (e.g., an expression).

```rust
['🙈', '🙊', '🙉']
    .iter()
    .cycle()
    .take(6)
    .collect::<String>()
```

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

### Example for as_ref

Source: https://docs.rs/leptos/latest/leptos/reactive/send_wrapper_ext/struct.SendOption.html

Calculates the length of an Option<String> as an Option<usize> without moving the String, by using as_ref to get a reference.

```rust
let text: Option<String> = Some("Hello, world!".to_string());
// First, cast `Option<String>` to `Option<&String>` with `as_ref`,
// then consume *that* with `map`, leaving `text` on the stack.
let text_length: Option<usize> = text.as_ref().map(|s| s.len());
println!("still can print text: {:?}", text);
```

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

### Example Usage of access_unchecked_mut

Source: https://docs.rs/leptos/latest/leptos/server_fn/rkyv/fn.access_unchecked_mut.html

This example demonstrates how to use `access_unchecked_mut` to obtain a mutable reference to archived data and then modify its contents. It first serializes a struct into bytes, then uses `access_unchecked_mut` to get a mutable reference to the archived version, and finally mutates a field.

```APIDOC
## §Example
```rust
use rkyv::{
    to_bytes,
    access_unchecked_mut,
    util::Align,
    Archive,
    munge::munge,
    Serialize,
    Deserialize,
    rancor::Error,
};

#[derive(Archive, Serialize, Deserialize)]
struct Example {
    name: String,
    value: i32,
}

let value = Example {
    name: "pi".to_string(),
    value: 31415926,
};

let mut bytes = to_bytes::<Error>(&value).unwrap();

let mut archived = unsafe {
    access_unchecked_mut::<ArchivedExample>(&mut *bytes)
};
assert_eq!(archived.name, "pi");
assert_eq!(archived.value, 31415926);

// Because the access is mutable, we can mutate the archived data
munge!(let ArchivedExample { mut value, .. } = archived);
assert_eq!(*value, 31415926);
*value = 12345.into();
assert_eq!(*value, 12345);
```
```

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

### Alignment Examples

Source: https://docs.rs/leptos/latest/leptos/server_fn/inventory/core/mem/struct.Alignment.html

Illustrates how to use Alignment with pointer manipulation and assertions.

```APIDOC
## Alignment Examples

### Description
This example demonstrates the usage of `Alignment` in conjunction with `NonNull` pointers and the `mask` method for pointer manipulation.

### Code
```rust
#![feature(ptr_mask)]
#![feature(ptr_alignment_type)]
use std::mem::Alignment;
use std::ptr::NonNull;

#[repr(align(1))] struct Align1(u8);
#[repr(align(2))] struct Align2(u16);
#[repr(align(4))] struct Align4(u32);
let one = <NonNull<Align1>>::dangling().as_ptr();
let two = <NonNull<Align2>>::dangling().as_ptr();
let four = <NonNull<Align4>>::dangling().as_ptr();

assert_eq!(four.mask(Alignment::of::<Align1>().mask()), four);
assert_eq!(four.mask(Alignment::of::<Align2>().mask()), four);
assert_eq!(four.mask(Alignment::of::<Align4>().mask()), four);
assert_ne!(one.mask(Alignment::of::<Align4>().mask()), one);
```
```

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

### RangeBounds end_bound Example

Source: https://docs.rs/leptos/latest/leptos/server_fn/inventory/core/ops/trait.RangeBounds.html

Demonstrates how to get the end bound of a range using the end_bound() method. Works with unbounded and excluded end bounds.

```rust
use std::ops.Bound::*;
use std::ops.RangeBounds;

assert_eq!((3..).end_bound(), Unbounded);
assert_eq!((3..10).end_bound(), Excluded(&10));
```

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

### Using f64::math::floor

Source: https://docs.rs/leptos/latest/leptos/server_fn/inventory/core/f64/math/fn.floor.html

This example demonstrates the usage of the experimental `f64::math::floor` function. It requires the `core_float_math` feature to be enabled. Note that this function is for testing purposes and will be stabilized as an inherent method.

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

use core::f64;

let f = 3.7_f64;
let g = 3.0_f64;
let h = -3.7_f64;

assert_eq!(f64::math::floor(f), 3.0);
assert_eq!(f64::math::floor(g), 3.0);
assert_eq!(f64::math::floor(h), -4.0);

```

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

### Get alignment of i32

Source: https://docs.rs/leptos/latest/leptos/server_fn/inventory/core/mem/fn.align_of.html

Use `align_of` to determine the byte alignment required for `i32` values. This example asserts that the alignment is 4 bytes.

```rust
assert_eq!(4, align_of::<i32>());
```

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

### From<i64_le> Implementation

Source: https://docs.rs/leptos/latest/leptos/server_fn/inventory/core/prelude/v1/trait.From.html

Demonstrates conversion from i64_le to i64.

```APIDOC
## impl From<i64_le> for i64

This implementation allows a `i64_le` to be converted into an `i64`.

### Method
`From::from`

### Parameters
- `value`: `i64_le` - The little-endian 64-bit integer to convert.

### Returns
- `i64` - The converted 64-bit integer.
```

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

### into_remainder example

Source: https://docs.rs/leptos/latest/leptos/server_fn/inventory/core/iter/struct.ArrayChunks.html

Demonstrates how to use `into_remainder` to get an iterator over the elements not included in the last chunk. The returned iterator yields at most N-1 elements.

```rust
let x = [1,2,3,4,5].into_iter().array_chunks::<2>();
let mut rem = x.into_remainder();
assert_eq!(rem.next(), Some(5));
assert_eq!(rem.next(), None);

```

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

### Examples of __m256i Usage

Source: https://docs.rs/leptos/latest/leptos/server_fn/inventory/core/arch/x86_64/struct.__m256i.html

Illustrates how to create and use __m256i instances with common SIMD intrinsics.

```APIDOC
## §Examples
```rust
#[cfg(target_arch = "x86")]
use std::arch::x86::*;
#[cfg(target_arch = "x86_64")]
use std::arch::x86_64::*;

let all_bytes_zero = _mm256_setzero_si256();
let all_bytes_one = _mm256_set1_epi8(1);
let eight_i32 = _mm256_set_epi32(1, 2, 3, 4, 5, 6, 7, 8);
```
```

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

### arc_signal Function Signature and Usage

Source: https://docs.rs/leptos/latest/leptos/reactive/signal/fn.arc_signal.html

Demonstrates the signature of arc_signal and provides examples of its usage, including getting, setting, updating, and deriving values.

```APIDOC
## arc_signal

### Description
Creates a reference-counted signal. A signal is a piece of data that may change over time, and notifies other code when it has changed. This is the atomic unit of reactivity, which begins all other processes of updating.

Takes the initial value as an argument, and returns a tuple containing an `ArcReadSignal` and an `ArcWriteSignal`.

This returns reference-counted signals, which are `Clone` but not `Copy`. For arena-allocated `Copy` signals, use `signal`.

### Signature
```rust
pub fn arc_signal<T>(value: T) -> (ArcReadSignal<T>, ArcWriteSignal<T>)
```

### Usage Examples
```rust
let (count, set_count) = arc_signal(0);

// ✅ calling the getter clones and returns the value
//    this can be `count()` on nightly
assert_eq!(count.get(), 0);

// ✅ calling the setter sets the value
//    this can be `set_count(1)` on nightly
set_count.set(1);
assert_eq!(count.get(), 1);

// ❌ you could call the getter within the setter
// set_count.set(count.get() + 1);

// ✅ however it's more efficient to use .update() and mutate the value in place
set_count.update(|count: &mut i32| *count += 1);
assert_eq!(count.get(), 2);

// ✅ you can create "derived signals" with a Fn() -> T interface
let double_count = move || count.get() * 2;
set_count.set(0);
assert_eq!(double_count(), 0);
set_count.set(1);
assert_eq!(double_count(), 2);
```
```

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

### fn steps_between

Source: https://docs.rs/leptos/latest/leptos/server_fn/inventory/core/num/type.NonZeroU128.html

Returns the bounds on the number of successor steps required to get from start to end, similar to Iterator::size_hint(). This is a nightly-only experimental API.

```APIDOC
## fn steps_between( start: &NonZero<u128>, end: &NonZero<u128>, ) -> (usize, Option<usize>)

### Description
Returns the bounds on the number of _successor_ steps required to get from `start` to `end` like `Iterator::size_hint()`.

### Parameters
#### Path Parameters
- **start** (NonZero<u128>) - Required - The starting value.
- **end** (NonZero<u128>) - Required - The ending value.

### Returns
- **(usize, Option<usize>)** - A tuple where the first element is the lower bound and the second is an optional upper bound on the number of steps.
```

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

### ExactSizeIterator Basic Usage Example

Source: https://docs.rs/leptos/latest/leptos/server_fn/inventory/core/iter/trait.ExactSizeIterator.html

Demonstrates how a finite range knows its exact iteration count. Use `len()` to get the remaining number of elements.

```rust
let five = 0..5;

assert_eq!(5, five.len());
```

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

### Buf Trait: Get Current Chunk

Source: https://docs.rs/leptos/latest/leptos/server_fn/struct.Bytes.html

Returns a slice starting at the current position with a length between 0 and the remaining bytes. This allows for non-continuous internal representations.

```rust
fn chunk(&self) -> &[u8]
```

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

### Initialization

Source: https://docs.rs/leptos/latest/leptos/either/enum.EitherOf14Future.html

Utilities for creating instances from initialization functions.

```APIDOC
## initialize_from_function

### Description
Create an instance of this type from an initialization function.

### Signature
`fn initialize_from_function(f: fn() -> T) -> T`
```
Tokens:
Raw