GPUI

https://docs.rs/gpui/latest/gpui
Admin
GPUI is a hybrid immediate and retained mode, GPU-accelerated UI framework for Rust designed to...
Tokens:1,376,240
Snippets:18,351
Trust Score:9.7
Update:1 week ago
Show doc for...
Tokens:
Raw
### Timer::interval_at - periodic timer starting at instant example

Source: https://docs.rs/gpui/latest/gpui/struct.Timer.html

Creates a timer that emits events periodically, starting at the given start instant. The example creates a one-second interval starting now and awaits the next event.

```rust
use async_io::Timer;
use futures_lite::StreamExt;
use std::time::{Duration, Instant};

let start = Instant::now();
let period = Duration::from_secs(1);
Timer::interval_at(start, period).next().await;
```

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

### starts_with example: check if slice starts with a prefix

Source: https://docs.rs/gpui/latest/gpui/struct.GlobalElementId.html

Checks if a slice starts with a given prefix or equals the slice. Always returns true for an empty needle.

```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]));
```

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

### Point::min example

Source: https://docs.rs/gpui/latest/gpui/struct.Point.html

Example of using the min method to get a point with the minimum coordinates from two points.

```rust
let p1 = Point { x: 3, y: 7 };
let p2 = Point { x: 5, y: 2 };
let min_point = p1.min(&p2);
assert_eq!(min_point, Point { x: 3, y: 2 });
```

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

### Point::new example

Source: https://docs.rs/gpui/latest/gpui/struct.Point.html

Example of using the new constructor to create a Point and assert its coordinates.

```rust
use gpui::Point;
let p = Point::new(10, 20);
assert_eq!(p.x, 10);
assert_eq!(p.y, 20);
```

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

### Point struct example

Source: https://docs.rs/gpui/latest/gpui/struct.Point.html

Example of creating a Point with integer coordinates and printing it.

```rust
let point = Point { x: 10, y: 20 };
println!("{:?}", point); // Outputs: Point { x: 10, y: 20 }
```

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

### opacity method example with hsla()

Source: https://docs.rs/gpui/latest/gpui/struct.Hsla.html

Shows using the opacity method on a saturated blue color created with hsla() to get a color with around 10% opacity, suitable for hover or selected states.

```rust
use gpui::hsla;
let color = hsla(0.7, 1.0, 0.5, 0.7); // A saturated blue
let faded_color = color.opacity(0.16);
assert!((faded_color.a - 0.112).abs() < 1e-6);
```

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

### Point::max example

Source: https://docs.rs/gpui/latest/gpui/struct.Point.html

Example of using the max method to get a point with the maximum coordinates from two points.

```rust
let p1 = Point { x: 3, y: 7 };
let p2 = Point { x: 5, y: 2 };
let max_point = p1.max(&p2);
assert_eq!(max_point, Point { x: 5, y: 7 });
```

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

### Box::take example

Source: https://docs.rs/gpui/latest/gpui/type.InspectorRenderer.html

Example of using Box::take to consume a box without deallocating, then reusing the allocation with Box::write.

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

let c = Box::new(5);

// take the value out of the box
let (value, uninit) = Box::take(c);
assert_eq!(value, 5);

// reuse the box for a second value
let c = Box::write(uninit, 6);
assert_eq!(*c, 6);
```

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

### split example

Source: https://docs.rs/gpui/latest/gpui/struct.GlobalElementId.html

Demonstrates splitting a slice by a predicate. Shows that matched elements are excluded, and empty slices appear when matches are at the start, end, or adjacent.

```rust
let slice = [10, 40, 33, 20];
let mut iter = slice.split(|num| num % 3 == 0);

assert_eq!(iter.next().unwrap(), &[10, 40]);
assert_eq!(iter.next().unwrap(), &[20]);
assert!(iter.next().is_none());
```

```rust
let slice = [10, 40, 33];
let mut iter = slice.split(|num| num % 3 == 0);

assert_eq!(iter.next().unwrap(), &[10, 40]);
assert_eq!(iter.next().unwrap(), &[]);
assert!(iter.next().is_none());
```

```rust
let slice = [10, 6, 33, 20];
let mut iter = slice.split(|num| num % 3 == 0);

assert_eq!(iter.next().unwrap(), &[10]);
assert_eq!(iter.next().unwrap(), &[]);
assert_eq!(iter.next().unwrap(), &[20]);
assert!(iter.next().is_none());
```

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

### corner() example

Source: https://docs.rs/gpui/latest/gpui/struct.Bounds.html

Imports gpui types and calls corner(Corner::BottomLeft) to get the requested corner point.

```rust
use gpui::{Bounds, Corner, Point, Size};
let bounds = Bounds {
    origin: Point { x: 0, y: 0 },
    size: Size { width: 10, height: 20 },
};
let bottom_left = bounds.corner(Corner::BottomLeft);
assert_eq!(bottom_left, Point { x: 0, y: 20 });
```

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

### Point::magnitude example

Source: https://docs.rs/gpui/latest/gpui/struct.Point.html

Example of calculating the Euclidean distance from the origin to a point.

```rust
let p = Point { x: Pixels::from(3.0), y: Pixels::from(4.0) };
assert_eq!(p.magnitude(), 5.0);
```

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

### Application::run

Source: https://docs.rs/gpui/latest/gpui/struct.Application.html

Starts the application and invokes the provided callback once fully launched.

```APIDOC
## Application::run

### Description
Start the application. The provided callback will be called once the app is fully launched.

### Method
run

### Signature
pub fn run<F>(self, on_finish_launching: F)
where F: 'static + FnOnce(&mut App)

### Parameters
- **on_finish_launching** (F) - Required - A callback that is called once the app is fully launched.

### Returns
None
```

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

### From<T> for Box<T> conversion example

Source: https://docs.rs/gpui/latest/gpui/type.InspectorRenderer.html

Shows how to convert a value into a Box using Box::from, which allocates on the heap and moves the value from the stack. The example asserts that Box::from(x) equals Box::new(5).

```rust
let x = 5;
let boxed = Box::new(5);

assert_eq!(Box::from(x), boxed);
```

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

### start_window_resize

Source: https://docs.rs/gpui/latest/gpui/struct.Window.html

Start a window resize operation (Wayland).

```APIDOC
## start_window_resize

### Description
Start a window resize operation (Wayland).

### Method
start_window_resize

### Signature
pub fn start_window_resize(&self, edge: ResizeEdge)

### Parameters
- **edge** (ResizeEdge) - Required - The edge from which to resize.
```

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

### Box::clone_from_ref_in example

Source: https://docs.rs/gpui/latest/gpui/type.InspectorRenderer.html

Example of using Box::clone_from_ref_in to allocate memory in a given allocator and clone a value into it.

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

use std::alloc::System;

let hello: Box<str, System> = Box::clone_from_ref_in("hello", System);
```

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

### array_windows example

Source: https://docs.rs/gpui/latest/gpui/struct.GlobalElementId.html

Iterates over overlapping windows of N elements. Panics if N is zero. The example shows windows of size 2 over a slice of four integers.

```rust
let slice = [0, 1, 2, 3];
let mut iter = slice.array_windows();
assert_eq!(iter.next().unwrap(), &[0, 1]);
assert_eq!(iter.next().unwrap(), &[1, 2]);
assert_eq!(iter.next().unwrap(), &[2, 3]);
assert!(iter.next().is_none());
```

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

### Path::new

Source: https://docs.rs/gpui/latest/gpui/struct.Path.html

Creates a new path with the given starting point.

```APIDOC
## Path::new

### Description
Creates a new path with the given starting point.

### Method
Constructor

### Signature
```rust
pub fn new(start: Point<Pixels>) -> Self
```

### Parameters
- **start** (Point<Pixels>) - Required - The starting point of the path.

### Returns
- **Self** - A new Path instance.

```

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

### Point::scale example

Source: https://docs.rs/gpui/latest/gpui/struct.Point.html

Example of scaling a Point with Pixels coordinates by a factor, resulting in ScaledPixels.

```rust
let p = Point { x: Pixels::from(10.0), y: Pixels::from(20.0) };
let scaled_p = p.scale(1.5);
assert_eq!(scaled_p, Point { x: ScaledPixels::from(15.0), y: ScaledPixels::from(30.0) });
```

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

### Timer::at - timer at specific instant example

Source: https://docs.rs/gpui/latest/gpui/struct.Timer.html

Creates a timer that emits an event once at the given time instant. The example creates a timer for one second from now and awaits it.

```rust
use async_io::Timer;
use std::time::{Duration, Instant};

let now = Instant::now();
let when = now + Duration::from_secs(1);
Timer::at(when).await;
```

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

### Point::clamp example

Source: https://docs.rs/gpui/latest/gpui/struct.Point.html

Example of clamping a point to a range defined by min and max points, including an out-of-bounds case.

```rust
let p = Point { x: 10, y: 20 };
let min = Point { x: 0, y: 5 };
let max = Point { x: 15, y: 25 };
let clamped_p = p.clamp(&min, &max);
assert_eq!(clamped_p, Point { x: 10, y: 20 });

let p_out_of_bounds = Point { x: -5, y: 30 };
let clamped_p_out_of_bounds = p_out_of_bounds.clamp(&min, &max);
assert_eq!(clamped_p_out_of_bounds, Point { x: 0, y: 25 });
```

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

### Box::try_clone_from_ref_in example

Source: https://docs.rs/gpui/latest/gpui/type.InspectorRenderer.html

Example of using Box::try_clone_from_ref_in to allocate memory and clone a value, returning an error if allocation fails.

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

use std::alloc::System;

let hello: Box<str, System> = Box::try_clone_from_ref_in("hello", System)?;
```

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

### Timer::interval_at(start, period)

Source: https://docs.rs/gpui/latest/gpui/struct.Timer.html

Creates a timer that emits events periodically, starting at `start`.

```APIDOC
## Timer::interval_at(start, period)

### Description
Creates a timer that emits events periodically, starting at `start`.

### Method
`pub fn interval_at(start: Instant, period: Duration) -> Timer`

### Parameters
- `start` (Instant) - The start time for the first event.
- `period` (Duration) - The period between events.

### Returns
A `Timer` that emits events periodically starting at `start`.

### Example
```rust
use async_io::Timer;
use futures_lite::StreamExt;
use std::time::{Duration, Instant};

let start = Instant::now();
let period = Duration::from_secs(1);
Timer::interval_at(start, period).next().await;
```
```

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

### SmallVec append example

Source: https://docs.rs/gpui/latest/gpui/struct.GlobalElementId.html

Example from the append method documentation showing how to move all elements from one SmallVec into another, leaving the source empty.

```rust
let mut v0: SmallVec<[u8; 16]> = smallvec![1, 2, 3];
let mut v1: SmallVec<[u8; 32]> = smallvec![4, 5, 6];
v0.append(&mut v1);
assert_eq!(*v0, [1, 2, 3, 4, 5, 6]);
assert_eq!(*v1, []);
```

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

### Point::map example

Source: https://docs.rs/gpui/latest/gpui/struct.Point.html

Example of using the map method to convert a Point's coordinates from integers to floats.

```rust
let p = Point { x: 3, y: 4 };
let p_float = p.map(|coord| coord as f32);
assert_eq!(p_float, Point { x: 3.0, y: 4.0 });
```

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

### Example: Creating and scaling Pixels

Source: https://docs.rs/gpui/latest/gpui/struct.Pixels.html

Shows how to create a Pixels value from 10.0 and scale it by 2.0, resulting in ScaledPixels::from(20.0).

```rust
use gpui::{Pixels, ScaledPixels};

// Define a length of 10 pixels
let length = Pixels::from(10.0);

// Define a length and scale it by a factor of 2
let scaled_length = length.scale(2.0);
assert_eq!(scaled_length, ScaledPixels::from(20.0));
```

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

### key_bindings

Source: https://docs.rs/gpui/latest/gpui/struct.App.html

Gets all key bindings in the app.

```APIDOC
## key_bindings

### Description
Gets all key bindings in the app.

### Method
`pub fn key_bindings(&self) -> Rc<RefCell<Keymap>>`

### Returns
- `Rc<RefCell<Keymap>>` - The keymap containing all key bindings.

```

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

### setup

Source: https://docs.rs/gpui/latest/gpui/type.InspectorRenderer.html

Gets the setup information sent by the X11 server.

```APIDOC
## setup

### Description
Gets the setup information sent by the X11 server.

### Method
setup

### Signature
fn setup(&self) -> &Setup

### Parameters
None

### Returns
- **&Setup** - A reference to the setup information.

```

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

### Using AvailableSpace::min_size()

Source: https://docs.rs/gpui/latest/gpui/enum.AvailableSpace.html

Example showing how to create a Size with both dimensions set to AvailableSpace::MinContent using the min_size method.

```rust
use gpui::AvailableSpace;
let min_content_size = AvailableSpace::min_size();
assert_eq!(min_content_size.width, AvailableSpace::MinContent);
assert_eq!(min_content_size.height, AvailableSpace::MinContent);
```

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

### Scale Bounds by Display Factor

Source: https://docs.rs/gpui/latest/gpui/struct.Bounds.html

Example usage of the scale method on Bounds<Pixels>. It multiplies the origin and size by the given factor, returning a new Bounds<ScaledPixels>. The example uses a factor of 2.0 and asserts the resulting scaled bounds.

```rust
let bounds = Bounds {
    origin: Point { x: Pixels::from(10.0), y: Pixels::from(20.0) },
    size: Size { width: Pixels::from(30.0), height: Pixels::from(40.0) },
};
let display_scale_factor = 2.0;
let scaled_bounds = bounds.scale(display_scale_factor);
assert_eq!(scaled_bounds, Bounds {
    origin: Point {
        x: ScaledPixels::from(20.0),
        y: ScaledPixels::from(40.0),
    },
    size: Size {
        width: ScaledPixels::from(60.0),
        height: ScaledPixels::from(80.0)
    },
});
```

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

### open_with_system

Source: https://docs.rs/gpui/latest/gpui/struct.App.html

Opens the specified path with the system's default application.

```APIDOC
## open_with_system

### Description
Opens the specified path with the system's default application.

### Method
open_with_system

### Signature
pub fn open_with_system(&self, path: &Path)

### Parameters
- **path** (&Path) - Required - The path to open.
```

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

### Application::new

Source: https://docs.rs/gpui/latest/gpui/struct.Application.html

Builds an app with the given asset source.

```APIDOC
## Application::new

### Description
Builds an app with the given asset source.

### Method
new

### Signature
pub fn new() -> Self

### Parameters
None

### Returns
Self - A new Application instance.
```

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

### Timer::set_interval_at - reset timer to periodic starting at instant example

Source: https://docs.rs/gpui/latest/gpui/struct.Timer.html

Sets the timer to emit events periodically, starting at the given start instant. Note that resetting does not remove the waker associated with the polling task.

```rust
use async_io::Timer;
use futures_lite::StreamExt;
use std::time::{Duration, Instant};

let mut t = Timer::after(Duration::from_secs(1));

let start = Instant::now();
let period = Duration::from_secs(2);
t.set_interval_at(start, period);
```

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

### binary_search example

Source: https://docs.rs/gpui/latest/gpui/struct.GlobalElementId.html

Demonstrates binary_search on a slice, showing Ok for found, Err for not found, and handling of multiple matches.

```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, });
```

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

### open_with_system

Source: https://docs.rs/gpui/latest/gpui/struct.Context.html

Opens the specified path with the system’s default application.

```APIDOC
## open_with_system

### Description
Opens the specified path with the system’s default application.

### Method
pub fn open_with_system(&self, path: &Path)

### Parameters
- **path** (&Path) - Required - The path to open.

### Returns
None
```

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

### bottom_left() example

Source: https://docs.rs/gpui/latest/gpui/struct.Bounds.html

Creates a Bounds and calls bottom_left() to get the bottom-left corner point.

```rust
let bounds = Bounds {
    origin: Point { x: 0, y: 0 },
    size: Size { width: 10, height: 20 },
};
let bottom_left = bounds.bottom_left();
assert_eq!(bottom_left, Point { x: 0, y: 20 });
```

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

### bottom_right() example

Source: https://docs.rs/gpui/latest/gpui/struct.Bounds.html

Creates a Bounds and calls bottom_right() to get the bottom-right corner point.

```rust
let bounds = Bounds {
    origin: Point { x: 0, y: 0 },
    size: Size { width: 10, height: 20 },
};
let bottom_right = bounds.bottom_right();
assert_eq!(bottom_right, Point { x: 10, y: 20 });
```

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

### Edges<DefiniteLength>::zero() example

Source: https://docs.rs/gpui/latest/gpui/struct.Edges.html

Creates an Edges<DefiniteLength> with all edges set to zero length. Useful for specifying no padding or margin. The example asserts that all edges are zero pixels.

```rust
let no_edges = Edges::<DefiniteLength>::zero();
assert_eq!(no_edges.top, DefiniteLength::from(px(0.)));
assert_eq!(no_edges.right, DefiniteLength::from(px(0.)));
assert_eq!(no_edges.bottom, DefiniteLength::from(px(0.)));
assert_eq!(no_edges.left, DefiniteLength::from(px(0.)));
```

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

### top_right() example

Source: https://docs.rs/gpui/latest/gpui/struct.Bounds.html

Creates a Bounds and calls top_right() to get the top-right corner point.

```rust
let bounds = Bounds {
    origin: Point { x: 0, y: 0 },
    size: Size { width: 10, height: 20 },
};
let top_right = bounds.top_right();
assert_eq!(top_right, Point { x: 10, y: 0 });
```

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

### as_chunks example

Source: https://docs.rs/gpui/latest/gpui/struct.GlobalElementId.html

Splits the slice into `N`-element arrays and a remainder slice of length less than `N`. Panics if `N` is zero. The example shows basic usage and a `let-else` pattern for exact multiples.

```rust
let slice = ['l', 'o', 'r', 'e', 'm'];
let (chunks, remainder) = slice.as_chunks();
assert_eq!(chunks, &[['l', 'o'], ['r', 'e']]);
assert_eq!(remainder, &['m']);
```

```rust
let slice = ['R', 'u', 's', 't'];
let (chunks, []) = slice.as_chunks::<2>() else {
    panic!("slice didn't have even length")
};
assert_eq!(chunks, &[['R', 'u'], ['s', 't']]);
```

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

### binary_search_by example

Source: https://docs.rs/gpui/latest/gpui/struct.GlobalElementId.html

Demonstrates binary_search_by with a comparator function, showing Ok for found, Err for not found, and handling of multiple matches.

```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, });
```

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

### rchunks_exact example

Source: https://docs.rs/gpui/latest/gpui/struct.GlobalElementId.html

Iterates over exact chunks from the end, omitting the remainder. Panics if chunk_size is zero. The example shows chunks of size 2 and uses remainder() to get the leftover element.

```rust
let slice = ['l', 'o', 'r', 'e', 'm'];
let mut iter = slice.rchunks_exact(2);
assert_eq!(iter.next().unwrap(), &['e', 'm']);
assert_eq!(iter.next().unwrap(), &['o', 'r']);
assert!(iter.next().is_none());
assert_eq!(iter.remainder(), &['l']);
```

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

### get() example

Source: https://docs.rs/gpui/latest/gpui/struct.GlobalElementId.html

Returns a reference to an element or subslice depending on the type of index. Returns None if out of bounds.

```rust
let v = [10, 40, 30];
assert_eq!(Some(&40), v.get(1));
assert_eq!(Some(&[10, 40][..]), v.get(0..2));
assert_eq!(None, v.get(3));
assert_eq!(None, v.get(0..4));
```

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

### resize_with example

Source: https://docs.rs/gpui/latest/gpui/struct.GlobalElementId.html

Shows how to use resize_with to resize a SmallVec, filling new slots with values from a closure or Default::default().

```rust
let mut vec : SmallVec<[_; 4]> = smallvec![1, 2, 3];
vec.resize_with(5, Default::default);
assert_eq!(&*vec, &[1, 2, 3, 0, 0]);

let mut vec : SmallVec<[_; 4]> = smallvec![];
let mut p = 1;
vec.resize_with(4, || { p *= 2; p });
assert_eq!(&*vec, &[2, 4, 8, 16]);
```

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

### KeyContext::new_with_defaults

Source: https://docs.rs/gpui/latest/gpui/struct.KeyContext.html

Initializes a new KeyContext that contains an 'os' key set to either 'macos', 'linux', 'windows' or 'unknown'.

```APIDOC
## KeyContext::new_with_defaults

### Description
Initializes a new `KeyContext` that contains an `os` key set to either `macos`, `linux`, `windows` or `unknown`.

### Method
`pub fn new_with_defaults() -> Self`

### Parameters
None.

### Returns
- `Self` - A new `KeyContext` instance with the `os` key set.
```

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

### as_rchunks example

Source: https://docs.rs/gpui/latest/gpui/struct.GlobalElementId.html

Splits the slice into `N`-element arrays starting from the end, with a remainder slice at the beginning. Panics if `N` is zero.

```rust
let slice = ['l', 'o', 'r', 'e', 'm'];
let (remainder, chunks) = slice.as_rchunks();
assert_eq!(remainder, &['l']);
assert_eq!(chunks, &[['o', 'r'], ['e', 'm']]);
```

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

### start_window_move

Source: https://docs.rs/gpui/latest/gpui/struct.Window.html

Tells the compositor to take control of window movement.

```APIDOC
## start_window_move

### Description
Tells the compositor to take control of window movement (Wayland and X11). Events may not be received during a move operation.

### Method
pub fn start_window_move(&self)

### Parameters
None

### Returns
None
```

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

### iter: Iterate over slice elements

Source: https://docs.rs/gpui/latest/gpui/struct.GlobalElementId.html

Returns an iterator that yields all items from start to end. The example shows sequential access to each element and then None.

```rust
let x = &[1, 2, 4];
let mut iterator = x.iter();

assert_eq!(iterator.next(), Some(&1));
assert_eq!(iterator.next(), Some(&2));
assert_eq!(iterator.next(), Some(&4));
assert_eq!(iterator.next(), None);
```

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

### as_simd example

Source: https://docs.rs/gpui/latest/gpui/struct.GlobalElementId.html

Splits a slice into prefix, SIMD middle, and suffix. Requires nightly feature portable_simd. Shows a basic SIMD sum function.

```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);
```

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

### action_documentation

Source: https://docs.rs/gpui/latest/gpui/struct.App.html

Gets a map from an action name to the documentation.

```APIDOC
## action_documentation

### Description
Gets a map from an action name to the documentation.

### Method
`pub fn action_documentation(&self) -> &HashMap<&'static str, &'static str>`

### Returns
- `&HashMap<&'static str, &'static str>` - A map from action names to documentation.

```

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

### Create an entity with cx.new

Source: https://docs.rs/gpui/latest/gpui/_ownership_and_data_flow/index.html

Shows the basic pattern for creating an entity in GPUI. The `run` callback receives an `App` reference, and `cx.new` creates an entity and returns an `Entity<Counter>` handle.

```rust
Application::new().run(|cx: &mut App| {
    let _counter: Entity<Counter> = cx.new(|_cx| Counter { count: 0 });
    // ...
});
```

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

### fn new_window_entity<T: 'static>(&mut self, build_entity: impl FnOnce(&mut Window, &mut Context<'_, T>) -> T) -> Self::Result<Entity<T>>

Source: https://docs.rs/gpui/latest/gpui/trait.VisualContext.html

Creates a new entity with access to the window.

```APIDOC
## new_window_entity

### Description
Create a new entity, with access to `Window`.

### Method
`fn new_window_entity<T: 'static>(&mut self, build_entity: impl FnOnce(&mut Window, &mut Context<'_, T>) -> T) -> Self::Result<Entity<T>>`

### Parameters
- `build_entity: impl FnOnce(&mut Window, &mut Context<'_, T>) -> T` - A closure that builds the entity.

### Returns
- `Self::Result<Entity<T>>` - The newly created entity.

```

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

### Timer::set_interval_at(start, period)

Source: https://docs.rs/gpui/latest/gpui/struct.Timer.html

Sets the timer to emit events periodically, starting at `start`.

```APIDOC
## Timer::set_interval_at(start, period)

### Description
Sets the timer to emit events periodically, starting at `start`. Note that resetting a timer is different from creating a new timer because `set_interval_at()` does not remove the waker associated with the task that is polling the timer.

### Method
`pub fn set_interval_at(&mut self, start: Instant, period: Duration)`

### Parameters
- `start` (Instant) - The start time for the first event.
- `period` (Duration) - The period between events.

### Returns
None.

### Example
```rust
use async_io::Timer;
use futures_lite::StreamExt;
use std::time::{Duration, Instant};

let mut t = Timer::after(Duration::from_secs(1));

let start = Instant::now();
let period = Duration::from_secs(2);
t.set_interval_at(start, period);
```
```

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

### KeyBinding::new

Source: https://docs.rs/gpui/latest/gpui/struct.KeyBinding.html

Constructs a new keybinding from the given keystrokes, action, and optional context. Panics on parse error.

```APIDOC
## KeyBinding::new

### Description
Construct a new keybinding from the given data. Panics on parse error.

### Method
`pub fn new<A: Action>(keystrokes: &str, action: A, context: Option<&str>) -> Self`

### Parameters
- `keystrokes` (&str) - Required - The keystrokes for the keybinding.
- `action` (A) - Required - The action associated with the keybinding.
- `context` (Option<&str>) - Optional - The context for the keybinding.

### Returns
- `Self` - The newly constructed KeyBinding.

### Errors
Panics on parse error.
```

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

### Box::new_uninit example

Source: https://docs.rs/gpui/latest/gpui/type.InspectorRenderer.html

Constructs a new box with uninitialized contents. Use write for deferred initialization and assume_init to finalize.

```rust
let mut five = Box::<u32>::new_uninit();
// Deferred initialization:
five.write(5);
let five = unsafe { five.assume_init() };

assert_eq!(*five, 5)
```

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

### Box::into_inner example

Source: https://docs.rs/gpui/latest/gpui/type.InspectorRenderer.html

Example of using Box::into_inner to extract the value from a boxed value.

```rust
assert_eq!(Box::into_inner(c), 5);
```

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

### opacity method example with gpui::red()

Source: https://docs.rs/gpui/latest/gpui/struct.Hsla.html

Shows using the opacity method on a red color from gpui::red() to create a faded color with half the opacity.

```rust
let color = gpui::red();
let faded_color = color.opacity(0.5);
assert_eq!(faded_color.a, 0.5);
```

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

### Clone example for Box

Source: https://docs.rs/gpui/latest/gpui/type.InspectorRenderer.html

Shows how to clone a Box and verify that the values are equal but the objects are unique.

```rust
let x = Box::new(5);
let y = x.clone();

// The value is the same
assert_eq!(x, y);

// But they are unique objects
assert_ne!(&*x as *const i32, &*y as *const i32);
```

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

### clone_from example for Box

Source: https://docs.rs/gpui/latest/gpui/type.InspectorRenderer.html

Shows how to copy the contents of one Box into another without creating a new allocation.

```rust
let x = Box::new(5);
let mut y = Box::new(10);
let yp: *const i32 = &*y;

y.clone_from(&x);

// The value is the same
assert_eq!(x, y);

// And no allocation occurred
assert_eq!(yp, &*y);
```

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

### open_window

Source: https://docs.rs/gpui/latest/gpui/struct.AsyncApp.html

Opens a new window with the given options and root view.

```APIDOC
## open_window

### Description
Open a window with the given options based on the root view returned by the given function.

### Method
open_window

### Signature
pub fn open_window<V>(
    &self,
    options: WindowOptions,
    build_root_view: impl FnOnce(&mut Window, &mut App) -> Entity<V>,
) -> Result<WindowHandle<V>>
where
    V: 'static + Render,

### Parameters
- `options` (WindowOptions) - Required - The options for the new window.
- `build_root_view` (FnOnce(&mut Window, &mut App) -> Entity<V>) - Required - A function that builds the root view for the window.

### Returns
- `Result<WindowHandle<V>>` - A handle to the new window, or an error if the App has been dropped.
```

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

### Pointable::init

Source: https://docs.rs/gpui/latest/gpui/struct.GpuiBorrow.html

Initializes a with the given initializer.

```APIDOC
## init

### Description
Initializes a with the given initializer.

### Method
init

### Signature
unsafe fn init(init: <T as Pointable>::Init) -> usize

### Parameters
- **init** (<T as Pointable>::Init) - Required - The initializer value.

### Returns
- **usize** - The pointer representation.

```

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

### chunk_by example: grouping equal elements

Source: https://docs.rs/gpui/latest/gpui/struct.GlobalElementId.html

Groups consecutive elements that satisfy the predicate. The example groups equal numbers into runs.

```rust
let slice = &[1, 1, 1, 3, 3, 2, 2, 2];

let mut iter = slice.chunk_by(|a, b| a == b);

assert_eq!(iter.next(), Some(&[1, 1, 1][..]));
assert_eq!(iter.next(), Some(&[3, 3][..]));
assert_eq!(iter.next(), Some(&[2, 2, 2][..]));
assert_eq!(iter.next(), None);
```

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

### Using Edges::all to set uniform edges

Source: https://docs.rs/gpui/latest/gpui/struct.Edges.html

Example of using the all() constructor to set all sides to the same value.

```rust
let uniform_edges = Edges::all(10.0);
assert_eq!(uniform_edges.top, 10.0);
assert_eq!(uniform_edges.right, 10.0);
assert_eq!(uniform_edges.bottom, 10.0);
assert_eq!(uniform_edges.left, 10.0);
```

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

### on_hover

Source: https://docs.rs/gpui/latest/gpui/struct.Interactivity.html

Binds a callback to the hover start and end events of the element. The boolean passed to the callback is true when hover starts and false when it ends.

```APIDOC
## on_hover

### Description
Binds a callback to the hover start and end events of the element. The boolean passed to the callback is true when hover starts and false when it ends.

### Method
`pub fn on_hover(&mut self, listener: impl Fn(&bool, &mut Window, &mut App) + 'static,)`

### Parameters
- `listener` (impl Fn(&bool, &mut Window, &mut App) + 'static) - Required - Callback invoked on hover start and end events.

### Notes
- The boolean is `true` when hover starts and `false` when it ends.
- See `Context::listener` to get access to a view's state from this callback.
```

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

### Example: Converting DefiniteLength to Pixels

Source: https://docs.rs/gpui/latest/gpui/enum.DefiniteLength.html

Shows how to use `to_pixels` with absolute lengths in pixels and rems, and a fraction, using a base size of 100 pixels and a rem size of 16 pixels.

```rust
let length_in_pixels = DefiniteLength::Absolute(AbsoluteLength::Pixels(px(42.0)));
let length_in_rems = DefiniteLength::Absolute(AbsoluteLength::Rems(rems(2.0)));
let length_as_fraction = DefiniteLength::Fraction(0.5);
let base_size = AbsoluteLength::Pixels(px(100.0));
let rem_size = px(16.0);

assert_eq!(length_in_pixels.to_pixels(base_size, rem_size), Pixels::from(42.0));
assert_eq!(length_in_rems.to_pixels(base_size, rem_size), Pixels::from(32.0));
assert_eq!(length_as_fraction.to_pixels(base_size, rem_size), Pixels::from(50.0));
```

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

### Timer::interval - periodic timer example

Source: https://docs.rs/gpui/latest/gpui/struct.Timer.html

Creates a timer that emits events periodically. The example creates a one-second interval and awaits the next event.

```rust
use async_io::Timer;
use futures_lite::StreamExt;
use std::time::{Duration, Instant};

let period = Duration::from_secs(1);
Timer::interval(period).next().await;
```

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

### split_at example

Source: https://docs.rs/gpui/latest/gpui/struct.GlobalElementId.html

Divides a slice into two at a given index. Panics if mid > len. The example shows splitting at indices 0, 2, and 3.

```rust
let v = ['a', 'b', 'c'];

{
   let (left, right) = v.split_at(0);
   assert_eq!(left, []);
   assert_eq!(right, ['a', 'b', 'c']);
}

{
    let (left, right) = v.split_at(2);
    assert_eq!(left, ['a', 'b']);
    assert_eq!(right, ['c']);
}

{
    let (left, right) = v.split_at(3);
    assert_eq!(left, ['a', 'b', 'c']);
    assert_eq!(right, []);
}
```

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

### start_picking

Source: https://docs.rs/gpui/latest/gpui/struct.Inspector.html

Starts element picking mode, allowing the user to select elements by clicking.

```APIDOC
## start_picking

### Description
Starts element picking mode, allowing the user to select elements by clicking.

### Method
pub fn start_picking(&mut self)

### Parameters
None

### Returns
- **()** - Nothing.
```

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

### Box::into_inner example

Source: https://docs.rs/gpui/latest/gpui/type.InspectorRenderer.html

Consumes the Box and returns the wrapped value. Requires the nightly box_into_inner feature. The example creates a Box with 5 and then calls into_inner.

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

let c = Box::new(5);
```

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

### KeyBinding::load

Source: https://docs.rs/gpui/latest/gpui/struct.KeyBinding.html

Loads a keybinding from raw data, including a context predicate and keyboard mapper.

```APIDOC
## KeyBinding::load

### Description
Load a keybinding from the given raw data.

### Method
`pub fn load(keystrokes: &str, action: Box<dyn Action>, context_predicate: Option<Rc<KeyBindingContextPredicate>>, use_key_equivalents: bool, action_input: Option<SharedString>, keyboard_mapper: &dyn PlatformKeyboardMapper) -> Result<Self, InvalidKeystrokeError>`

### Parameters
- `keystrokes` (&str) - Required - The keystrokes for the keybinding.
- `action` (Box<dyn Action>) - Required - The action associated with the keybinding.
- `context_predicate` (Option<Rc<KeyBindingContextPredicate>>) - Optional - The predicate used to match the binding.
- `use_key_equivalents` (bool) - Required - Whether to use key equivalents.
- `action_input` (Option<SharedString>) - Optional - The action input associated with the action.
- `keyboard_mapper` (&dyn PlatformKeyboardMapper) - Required - The platform keyboard mapper.

### Returns
- `Result<Self, InvalidKeystrokeError>` - The loaded KeyBinding or an error.
```

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

### Box::leak simple usage example

Source: https://docs.rs/gpui/latest/gpui/type.InspectorRenderer.html

Leaks a Box and obtains a mutable reference with a chosen lifetime. The example uses 'static and modifies the leaked value.

```rust
let x = Box::new(41);
let static_ref: &'static mut usize = Box::leak(x);
*static_ref += 1;
assert_eq!(*static_ref, 42);
```

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

### prompt_for_new_path

Source: https://docs.rs/gpui/latest/gpui/struct.Context.html

Displays a platform modal for selecting a new path where a file can be saved. The provided directory will be used to set the initial location. When a path is selected, it is relayed asynchronously via the returned oneshot channel. If cancelled, a `None` will be relayed instead. May return an error on Linux if the file picker couldn’t be opened.

```APIDOC
## prompt_for_new_path

### Description
Displays a platform modal for selecting a new path where a file can be saved. The provided directory will be used to set the initial location. When a path is selected, it is relayed asynchronously via the returned oneshot channel. If cancelled, a `None` will be relayed instead. May return an error on Linux if the file picker couldn’t be opened.

### Method
pub fn prompt_for_new_path(&self, directory: &Path, suggested_name: Option<&str>) -> Receiver<Result<Option<PathBuf>>>

### Parameters
- **directory** (&Path) - Required - The initial directory for the file picker.
- **suggested_name** (Option<&str>) - Optional - A suggested name for the file.

### Returns
- Receiver<Result<Option<PathBuf>>> - A receiver that yields the selected path or None if cancelled.
```

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

### binary_search_by_key example

Source: https://docs.rs/gpui/latest/gpui/struct.GlobalElementId.html

Searches a slice of pairs by their second element. Demonstrates Ok and Err results, and that multiple matches may return any matching index.

```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, });
```

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

### Corners::corner example

Source: https://docs.rs/gpui/latest/gpui/struct.Corners.html

Returns the value of a specific corner using the Corner enum. The example uses a Corners with integer values and retrieves the bottom-left corner.

```rust
let corners = Corners {
    top_left: 1,
    top_right: 2,
    bottom_left: 3,
    bottom_right: 4
};
assert_eq!(corners.corner(Corner::BottomLeft), 3);
```

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

### partition_point basic example

Source: https://docs.rs/gpui/latest/gpui/struct.GlobalElementId.html

Finds the partition point of a slice according to a predicate. The slice must be partitioned; otherwise the result is unspecified.

```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)));
```

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

### Creating a Bounds with new

Source: https://docs.rs/gpui/latest/gpui/struct.Bounds.html

Example of creating a Bounds using the new constructor and asserting its fields.

```rust
let origin = Point { x: 0, y: 0 };
let size = Size { width: 10, height: 20 };
let bounds = Bounds::new(origin, size);

assert_eq!(bounds.origin, origin);
assert_eq!(bounds.size, size);
```

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

### rchunks example

Source: https://docs.rs/gpui/latest/gpui/struct.GlobalElementId.html

Iterates over chunks from the end of the slice. Panics if chunk_size is zero. The example shows chunks of size 2 from a slice of characters, with the last chunk possibly smaller.

```rust
let slice = ['l', 'o', 'r', 'e', 'm'];
let mut iter = slice.rchunks(2);
assert_eq!(iter.next().unwrap(), &['e', 'm']);
assert_eq!(iter.next().unwrap(), &['o', 'r']);
assert_eq!(iter.next().unwrap(), &['l']);
assert!(iter.next().is_none());
```

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

### Edges<AbsoluteLength>::zero() example

Source: https://docs.rs/gpui/latest/gpui/struct.Edges.html

Creates an Edges<AbsoluteLength> with all edges set to zero pixels. Useful for specifying no padding or margin. The example asserts that all edges are zero pixels.

```rust
let no_edges = Edges::<AbsoluteLength>::zero();
assert_eq!(no_edges.top, AbsoluteLength::Pixels(Pixels::ZERO));
assert_eq!(no_edges.right, AbsoluteLength::Pixels(Pixels::ZERO));
assert_eq!(no_edges.bottom, AbsoluteLength::Pixels(Pixels::ZERO));
assert_eq!(no_edges.left, AbsoluteLength::Pixels(Pixels::ZERO));
```

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

### fn tooltip(self, build_tooltip: impl Fn(&mut Window, &mut App) -> AnyView + 'static) -> Self

Source: https://docs.rs/gpui/latest/gpui/trait.StatefulInteractiveElement.html

Uses the given callback to construct a new tooltip view when the mouse hovers over this element.

```APIDOC
## fn tooltip(self, build_tooltip: impl Fn(&mut Window, &mut App) -> AnyView + 'static) -> Self

### Description
Uses the given callback to construct a new tooltip view when the mouse hovers over this element. The fluent API equivalent to `Interactivity::tooltip`.

### Method
tooltip

### Signature
`fn tooltip(self, build_tooltip: impl Fn(&mut Window, &mut App) -> AnyView + 'static) -> Self`

### Parameters
- **build_tooltip** (`impl Fn(&mut Window, &mut App) -> AnyView + 'static`) - Required - A callback that constructs the tooltip view.

### Returns
`Self` - The element with the tooltip handler bound.
```
Tokens:
Raw