rquickjs

https://docs.rs/rquickjs/latest/rquickjs/
Admin
rquickjs is a Rust binding for the QuickJS JavaScript engine, enabling seamless execution and...
Tokens:470,224
Snippets:5,597
Trust Score:9.1
Update:2 months ago
Show doc for...
Tokens:
Raw
### Trim start matches example

Source: https://docs.rs/rquickjs/latest/rquickjs/alloc/string/struct.String.html

Demonstrates trimming characters from the start of a string slice.

```rust
let x: &[_] = &['1', '2'];
assert_eq!("12foo1bar12".trim_start_matches(x), "foo1bar12");
```

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

### Seeking in a File

Source: https://docs.rs/rquickjs/latest/rquickjs/alloc/io/trait.Seek.html

Example demonstrating how to use the seek method on a file to move the cursor 42 bytes from the start.

```rust
use std::io;
use std::io::prelude::*;
use std::fs::File;
use std::io::SeekFrom;

fn main() -> io::Result<()> {
    let mut f = File::open("foo.txt")?;

    // move the cursor 42 bytes from the start of the file
    f.seek(SeekFrom::Start(42))?;
    Ok(())
}
```

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

### Option::into_flat_iter Example

Source: https://docs.rs/rquickjs/latest/rquickjs/qjs/type.JSFreeArrayBufferDataFunc.html

Example usage of the experimental into_flat_iter method on Option.

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

let o1 = Some([1, 2]);
let o2 = None::<&[usize]>;

assert_eq!(o1.into_flat_iter().collect::<Vec<_>>(), [1, 2]);
assert_eq!(o2.into_flat_iter().collect::<Vec<_>>(), Vec::<&usize>::new());
```

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

### Basic Box Initialization

Source: https://docs.rs/rquickjs/latest/rquickjs/runtime/type.InterruptHandler.html

Standard Box creation and pinning examples.

```rust
let foo = Box::new(());
let bar = Pin::from(foo);
```

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

### Option::is_none_or Example

Source: https://docs.rs/rquickjs/latest/rquickjs/qjs/type.JSFreeArrayBufferDataFunc.html

Example usage of the is_none_or method.

```rust
let x: Option<u32> = Some(2);
assert_eq!(x.is_none_or(|x| x > 1), true);

let x: Option<u32> = Some(0);
assert_eq!(x.is_none_or(|x| x > 1), false);

let x: Option<u32> = None;
assert_eq!(x.is_none_or(|x| x > 1), true);

let x: Option<String> = Some("ownership".to_string());
assert_eq!(x.as_ref().is_none_or(|x| x.len() > 1), true);
println!("still alive {:?}", x);
```

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

### Slice Conversion

Source: https://docs.rs/rquickjs/latest/rquickjs/prelude/struct.Opt.html

Examples for converting options to slices.

```rust
assert_eq!(
    [Some(1234).as_slice(), None.as_slice()],
    [&[1234][..], &[][..]],
);
```

```rust
for i in [Some(1234_u16), None] {
    assert_eq!(i.as_ref(), i.as_slice().first());
}
```

```rust
assert_eq!(
    [Some(1234).as_mut_slice(), None.as_mut_slice()],
    [&mut [1234][..], &mut [][..]],
);
```

```rust
let mut x = Some(1234);
x.as_mut_slice()[0] += 1;
assert_eq!(x, Some(1235));
```

```rust
assert_eq!(Some(123).as_mut_slice().first_mut(), Some(&mut 123))
```

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

### Normalize module name logic

Source: https://docs.rs/rquickjs/latest/rquickjs/loader/trait.Resolver.html

Example implementation logic for resolving module paths based on whether they start with a dot.

```rust
Ok(if !name.starts_with('.') {
    name.into()
} else {
    let mut split = base.rsplitn(2, '/');
    let path = match (split.next(), split.next()) {
        (_, Some(path)) => path,
        _ => "",
    };
    format!("{path}/{name}")
})
```

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

### Using module_init for Module Export

Source: https://docs.rs/rquickjs/latest/rquickjs/macro.module_init.html

Example showing how to implement ModuleDef and register it using the module_init macro.

```rust
use rquickjs::{module::ModuleDef, module_init};

struct MyModule;
impl ModuleDef for MyModule {}

module_init!(MyModule);
// or
module_init!(js_init_my_module: MyModule);
```

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

### Option::is_some_and Example

Source: https://docs.rs/rquickjs/latest/rquickjs/qjs/type.JSFreeArrayBufferDataFunc.html

Example usage of the is_some_and method with a predicate.

```rust
let x: Option<u32> = Some(2);
assert_eq!(x.is_some_and(|x| x > 1), true);

let x: Option<u32> = Some(0);
assert_eq!(x.is_some_and(|x| x > 1), false);

let x: Option<u32> = None;
assert_eq!(x.is_some_and(|x| x > 1), false);

let x: Option<String> = Some("ownership".to_string());
assert_eq!(x.as_ref().is_some_and(|x| x.len() > 1), true);
println!("still alive {:?}", x);
```

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

### Check string prefix

Source: https://docs.rs/rquickjs/latest/rquickjs/alloc/string/struct.String.html

Verifies if the string starts with a specific pattern.

```rust
let bananas = "bananas";

assert!(bananas.starts_with("bana"));
assert!(!bananas.starts_with("nana"));
```

```rust
let bananas = "bananas";

// Note that both of these assert successfully.
assert!(bananas.starts_with(&['b', 'a', 'n', 'a']));
assert!(bananas.starts_with(&['a', 'b', 'c', 'd']));
```

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

### Trim start matches

Source: https://docs.rs/rquickjs/latest/rquickjs/alloc/string/struct.String.html

Removes prefixes that match a provided pattern.

```rust
assert_eq!("11foo1bar11".trim_start_matches('1'), "foo1bar11");
assert_eq!("123foo1bar123".trim_start_matches(char::is_numeric), "foo1bar123");
```

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

### Runtime::new

Source: https://docs.rs/rquickjs/latest/rquickjs/struct.Runtime.html

Creates a new QuickJS runtime instance. This is the primary entry point for initializing the engine.

```APIDOC
## pub fn new() -> Result<Runtime, Error>

### Description
Creates a new runtime. Will generally only fail if not enough memory was available.

### Features
If the "rust-alloc" feature is enabled the Rust’s global allocator will be used in favor of libc’s one.
```

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

### Demonstrating ambiguous From implementation

Source: https://docs.rs/rquickjs/latest/rquickjs/runtime/type.InterruptHandler.html

An example of a discouraged From implementation that creates ambiguity when calling Pin::from.

```rust
struct Foo; // A type defined in this crate.
impl From<Box<()>> for Pin<Foo> {
    fn from(_: Box<()>) -> Pin<Foo> {
        Pin::new(Foo)
    }
}
```

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

### Runtime Initialization

Source: https://docs.rs/rquickjs/latest/rquickjs/runtime/struct.Runtime.html

Methods for creating a new QuickJS runtime instance.

```APIDOC
## Runtime::new()

### Description
Creates a new QuickJS runtime instance. May fail if memory allocation is unsuccessful.

### Signature
`pub fn new() -> Result<Runtime, Error>`

## Runtime::new_with_alloc<A>(allocator: A)

### Description
Creates a new runtime using a custom allocator.

### Signature
`pub fn new_with_alloc<A>(allocator: A) -> Result<Runtime, Error> where A: Allocator + 'static`
```

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

### Retrieve match indices

Source: https://docs.rs/rquickjs/latest/rquickjs/alloc/string/struct.String.html

Use match_indices to get the start index and content of disjoint pattern matches.

```rust
let v: Vec<_> = "abcXXXabcYYYabc".match_indices("abc").collect();
assert_eq!(v, [(0, "abc"), (6, "abc"), (12, "abc")]);

let v: Vec<_> = "1abcabc2".match_indices("abc").collect();
assert_eq!(v, [(1, "abc"), (4, "abc")]);

let v: Vec<_> = "ababa".match_indices("aba").collect();
assert_eq!(v, [(0, "aba")]); // only the first `aba`
```

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

### format Macro Usage Examples

Source: https://docs.rs/rquickjs/latest/rquickjs/alloc/macro.format.html

Common patterns for string interpolation using the format macro.

```rust
format!("test");                             // => "test"
format!("hello {}", "world!");               // => "hello world!"
format!("x = {}, y = {val}", 10, val = 30);  // => "x = 10, y = 30"
let (x, y) = (1, 2);
format!("{x} + {y} = 3");                    // => "1 + 2 = 3"
```

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

### Product Operation Example

Source: https://docs.rs/rquickjs/latest/rquickjs/qjs/type.JSFreeArrayBufferDataFunc.html

Demonstrates using the product method on an iterator of Options, where a None value short-circuits the calculation.

```rust
assert_eq!(res, None);
assert_eq!(shared, 6);
```

```rust
let nums = vec!["5", "10", "1", "2"];
let total: Option<usize> = nums.iter().map(|w| w.parse::<usize>().ok()).product();
assert_eq!(total, Some(100));
let nums = vec!["5", "10", "one", "2"];
let total: Option<usize> = nums.iter().map(|w| w.parse::<usize>().ok()).product();
```

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

### Retrieve reverse match indices

Source: https://docs.rs/rquickjs/latest/rquickjs/alloc/string/struct.String.html

Use rmatch_indices to get the start index and content of disjoint pattern matches in reverse order.

```rust
let v: Vec<_> = "abcXXXabcYYYabc".rmatch_indices("abc").collect();
assert_eq!(v, [(12, "abc"), (6, "abc"), (0, "abc")]);

let v: Vec<_> = "1abcabc2".rmatch_indices("abc").collect();
assert_eq!(v, [(4, "abc"), (1, "abc")]);

let v: Vec<_> = "ababa".rmatch_indices("aba").collect();
assert_eq!(v, [(2, "aba")]); // only the last `aba`
```

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

### Configure module attribute options

Source: https://docs.rs/rquickjs/latest/rquickjs/attr.module.html

Examples of passing arguments to the module attribute or using the qjs attribute for configuration.

```rust
#[module(rename = "AnotherName")]
```

```rust
#[qjs(rename = "AnotherName")]
```

```rust
#[qjs(flag)]
```

```rust
#[qjs(flag = true)]
```

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

### Basic usage of format

Source: https://docs.rs/rquickjs/latest/rquickjs/alloc/fmt/fn.format.html

Demonstrates creating a formatted string using the format function and format_args! macro.

```rust
use std::fmt;

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

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

### get

Source: https://docs.rs/rquickjs/latest/rquickjs/alloc/collections/btree_set/struct.VacantEntry.html

Gets a reference to the value that would be used when inserting through the VacantEntry.

```APIDOC
## pub fn get(&self) -> &T

### Description
Gets a reference to the value that would be used when inserting through the VacantEntry.
```

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

### step_by

Source: https://docs.rs/rquickjs/latest/rquickjs/alloc/collections/binary_heap/struct.IntoIter.html

Creates an iterator starting at the same point, but stepping by the given amount at each iteration.

```APIDOC
## fn step_by(self, step: usize) -> StepBy<Self>

### Description
Creates an iterator starting at the same point, but stepping by the given amount at each iteration.
```

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

### Implement Display and Binary traits for a custom struct

Source: https://docs.rs/rquickjs/latest/rquickjs/alloc/fmt/index.html

Example showing how to implement Display for standard output and Binary for custom formatted output on a struct.

```rust
use std::fmt;

#[derive(Debug)]
struct Vector2D {
    x: isize,
    y: isize,
}

impl fmt::Display for Vector2D {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        // The `f` value implements the `Write` trait, which is what the
        // write! macro is expecting. Note that this formatting ignores the
        // various flags provided to format strings.
        write!(f, "({}, {})", self.x, self.y)
    }
}

// Different traits allow different forms of output of a type. The meaning
// of this format is to print the magnitude of a vector.
impl fmt::Binary for Vector2D {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        let magnitude = (self.x * self.x + self.y * self.y) as f64;
        let magnitude = magnitude.sqrt();

        // Respect the formatting flags by using the helper method
        // `pad_integral` on the Formatter object. See the method
        // documentation for details, and the function `pad` can be used
        // to pad strings.
        let decimals = f.precision().unwrap_or(3);
        let string = format!("{magnitude:.decimals$}");
        f.pad_integral(true, "", &string)
    }
}

fn main() {
    let myvector = Vector2D { x: 3, y: 4 };

    println!("{myvector}");       // => "(3, 4)"
    println!("{myvector:?}");     // => "Vector2D {x: 3, y:4}"
    println!("{myvector:10.3b}"); // => "     5.000"
}
```

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

### Incorrect JsLifetime implementation examples

Source: https://docs.rs/rquickjs/latest/rquickjs/prelude/trait.JsLifetime.html

Examples of unsound implementations that fail to correctly map the 'js lifetime.

```rust
struct Container<'js>(rquickjs::Object<'js>);

unsafe impl<'a,'js> JsLifetime<'js> for Container<'a>{ // WRONG LIFETIME!
    type Changed<'to> = Container<'to>;
}
```

```rust
// Her 'a is not derived from an Javascript value type, but instead the lifetime of a reference.
struct Container<'a,'js>(&'a rquickjs::Object<'js>);

// Non 'js lifetime marked as a 'js lifetime. Unsound!
unsafe impl<'js> JsLifetime<'js> for Container<'js, 'js>{
    type Changed<'to> = Container<'to,'to>;
}
```

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

### Using the Entry API

Source: https://docs.rs/rquickjs/latest/rquickjs/alloc/collections/btree_map/struct.BTreeMap.html

Demonstrates complex key-value manipulation using the Entry API.

```rust
use std::collections::BTreeMap;

// type inference lets us omit an explicit type signature (which
// would be `BTreeMap<&str, u8>` in this example).
let mut player_stats = BTreeMap::new();

fn random_stat_buff() -> u8 {
    // could actually return some random value here - let's just return
    // some fixed value for now
    42
}

// insert a key only if it doesn't already exist
player_stats.entry("health").or_insert(100);

// insert a key using a function that provides a new value only if it
// doesn't already exist
player_stats.entry("defence").or_insert_with(random_stat_buff);

// update a key, guarding against the key possibly not being set
let stat = player_stats.entry("attack").or_insert(100);
*stat += random_stat_buff();

// modify an entry before an insert with in-place mutation
player_stats.entry("mana").and_modify(|mana| *mana += 200).or_insert(100);
```

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

### Check Vector Capacity

Source: https://docs.rs/rquickjs/latest/rquickjs/alloc/bstr/struct.ByteString.html

Examples demonstrating how to check the capacity of a vector, including cases with zero-sized elements.

```rust
let mut vec: Vec<i32> = Vec::with_capacity(10);
vec.push(42);
assert!(vec.capacity() >= 10);
```

```rust
#[derive(Clone)]
struct ZeroSized;

fn main() {
    assert_eq!(std::mem::size_of::<ZeroSized>(), 0);
    let v = vec![ZeroSized; 0];
    assert_eq!(v.capacity(), usize::MAX);
}
```

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

### Multiple Borrow Implementation Example

Source: https://docs.rs/rquickjs/latest/rquickjs/alloc/slice/trait.Concat.html

An example showing a struct implementing Borrow for multiple types, which necessitates the Item parameter in Concat.

```rust
pub struct Foo(Vec<u32>, Vec<String>);

impl std::borrow::Borrow<[u32]> for Foo {
    fn borrow(&self) -> &[u32] { &self.0 }
}

impl std::borrow::Borrow<[String]> for Foo {
    fn borrow(&self) -> &[String] { &self.1 }
}
```

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

### Registering a Global Allocator

Source: https://docs.rs/rquickjs/latest/rquickjs/alloc/alloc/trait.GlobalAllocator.html

Example of setting the System allocator as the global default using the #[global_allocator] attribute.

```rust
use std::alloc::System;

#[global_allocator]
static ALLOCATOR: System = System;
```

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

### Implementing and Using LocalWake

Source: https://docs.rs/rquickjs/latest/rquickjs/alloc/task/trait.LocalWake.html

A simplified example demonstrating task spawning and execution using LocalWake, LocalWaker, and a thread-local run queue.

```rust
#![feature(local_waker)]
use std::task::{LocalWake, ContextBuilder, LocalWaker, Waker};
use std::future::Future;
use std::pin::Pin;
use std::rc::Rc;
use std::cell::RefCell;
use std::collections::VecDeque;


thread_local! {
    // A queue containing all tasks ready to do progress
    static RUN_QUEUE: RefCell<VecDeque<Rc<Task>>> = RefCell::default();
}

type BoxedFuture = Pin<Box<dyn Future<Output = ()>>>;

struct Task(RefCell<BoxedFuture>);

impl LocalWake for Task {
    fn wake(self: Rc<Self>) {
        RUN_QUEUE.with_borrow_mut(|queue| {
            queue.push_back(self)
        })
    }
}

fn spawn<F>(future: F)
where
    F: Future<Output=()> + 'static + Send + Sync
{
    let task = RefCell::new(Box::pin(future));
    RUN_QUEUE.with_borrow_mut(|queue| {
        queue.push_back(Rc::new(Task(task)));
    });
}

fn block_on<F>(future: F)
where
    F: Future<Output=()> + 'static + Sync + Send
{
    spawn(future);
    loop {
        let Some(task) = RUN_QUEUE.with_borrow_mut(|queue| queue.pop_front()) else {
            // we exit, since there are no more tasks remaining on the queue
            return;
        };

        // cast the Rc<Task> into a `LocalWaker`
        let local_waker: LocalWaker = task.clone().into();
        // Build the context using `ContextBuilder`
        let mut cx = ContextBuilder::from_waker(Waker::noop())
            .local_waker(&local_waker)
            .build();

        // Poll the task
        let _ = task.0
            .borrow_mut()
            .as_mut()
            .poll(&mut cx);
    }
}

block_on(async {
    println!("hello world");
});
```

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

### Unconstrained Type Parameter Error Example

Source: https://docs.rs/rquickjs/latest/rquickjs/alloc/slice/trait.Concat.html

An example demonstrating why the Item type parameter is necessary to avoid unconstrained type parameter errors.

```rust
error[E0207]: the type parameter `T` is not constrained by the impl trait, self type, or predica
   --> library/alloc/src/slice.rs:608:6
    |
608 | impl<T: Clone, V: Borrow<[T]>> Concat for [V] {
    |      ^ unconstrained type parameter
```

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

### Trim start of string

Source: https://docs.rs/rquickjs/latest/rquickjs/alloc/string/struct.String.html

Demonstrates trimming leading whitespace from a string, noting that 'start' refers to the first byte position regardless of text directionality.

```rust
let s = "  עברית  ";
assert!(Some('ע') == s.trim_start().chars().next());
```

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

### Basic usage of fmt::write

Source: https://docs.rs/rquickjs/latest/rquickjs/alloc/fmt/fn.write.html

Demonstrates formatting arguments into a String using the fmt::write function.

```rust
use std::fmt;

let mut output = String::new();
fmt::write(&mut output, format_args!("Hello {}!", "world"))
    .expect("Error occurred while trying to write in String");
assert_eq!(output, "Hello world!");
```

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

### Initialize vector via as_non_null

Source: https://docs.rs/rquickjs/latest/rquickjs/alloc/bstr/struct.ByteString.html

Demonstrates manual initialization using the experimental as_non_null API.

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

// Allocate vector big enough for 4 elements.
let size = 4;
let mut x: Vec<i32> = Vec::with_capacity(size);
let x_ptr = x.as_non_null();

// Initialize elements via raw pointer writes, then set length.
unsafe {
    for i in 0..size {
        x_ptr.add(i).write(i as i32);
    }
    x.set_len(size);
}
assert_eq!(&*x, &[0, 1, 2, 3]);
```

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

### get

Source: https://docs.rs/rquickjs/latest/rquickjs/struct.Constructor.html

Retrieves the value of a property from the object.

```APIDOC
## pub fn get<K, V>(&self, k: K) -> Result<V, Error>

### Description
Get a value from the object by its key.
```

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

### JS_NewRuntime

Source: https://docs.rs/rquickjs/latest/rquickjs/qjs/fn.JS_NewRuntime.html

Creates a new QuickJS runtime instance.

```APIDOC
## JS_NewRuntime

### Description
Creates a new QuickJS runtime instance. This function is unsafe and returns a pointer to a JSRuntime.

### Signature
`pub unsafe extern "C" fn JS_NewRuntime() -> *mut JSRuntime`
```

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

### Expect and Unwrap Values

Source: https://docs.rs/rquickjs/latest/rquickjs/qjs/type.JSModuleInitFunc.html

Examples of extracting values from Option, including handling potential panics.

```rust
let x = Some("value");
assert_eq!(x.expect("fruits are healthy"), "value");
```

```rust
let x: Option<&str> = None;
x.expect("fruits are healthy"); // panics with `fruits are healthy`
```

```rust
let item = slice.get(0)
    .expect("slice should not be empty");
```

```rust
let x = Some("air");
assert_eq!(x.unwrap(), "air");
```

```rust
let x: Option<&str> = None;
assert_eq!(x.unwrap(), "air"); // fails
```

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

### get

Source: https://docs.rs/rquickjs/latest/rquickjs/alloc/collections/vec_deque/struct.VecDeque.html

Retrieves a reference to an element at a specific index.

```APIDOC
## pub fn get(&self, index: usize) -> Option<&T>

### Description
Provides a reference to the element at the given index, where index 0 is the front of the queue.
```

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

### AsyncRuntime::new

Source: https://docs.rs/rquickjs/latest/rquickjs/runtime/struct.AsyncRuntime.html

Creates a new asynchronous QuickJS runtime instance.

```APIDOC
## pub fn new() -> Result<AsyncRuntime, Error>

### Description
Creates a new runtime. Will generally only fail if not enough memory was available.
```

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

### Implement IntoJs for a tuple struct

Source: https://docs.rs/rquickjs/latest/rquickjs/derive.IntoJs.html

Example showing how to derive IntoJs for a tuple struct and use it within a QuickJS context.

```rust
use rquickjs::{CatchResultExt, Context, IntoJs, Runtime};

#[derive(IntoJs)]
struct Pair(u32, String);

let rt = Runtime::new().unwrap();
let ctx = Context::full(&rt).unwrap();
ctx.with(|ctx| {
    ctx.globals().set("pair", Pair(3, "gamma".into())).unwrap();
    ctx.eval::<(), _>(
        r#"if (pair[0] !== 3 || pair[1] !== "gamma") { throw new Error() }"#,
    )
    .catch(&ctx)
    .unwrap();
});
```

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

### get

Source: https://docs.rs/rquickjs/latest/rquickjs/alloc/collections/btree_map/struct.BTreeMap.html

Returns a reference to the value corresponding to the key.

```APIDOC
## pub fn get<Q>(&self, key: &Q) -> Option<&V>

### Description
Returns a reference to the value corresponding to the key. The key may be any borrowed form of the map’s key type.
```

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

### get(value)

Source: https://docs.rs/rquickjs/latest/rquickjs/alloc/collections/btree_set/struct.BTreeSet.html

Retrieves a reference to an element in the set.

```APIDOC
## pub fn get<Q>(&self, value: &Q) -> Option<&T>

### Description
Returns a reference to the element in the set, if any, that is equal to the value.
```

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

### Context Initialization and Access Methods

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

Methods for creating and interacting with a Context instance.

```rust
pub unsafe fn from_raw(ctx: NonNull<JSContext>, rt: Runtime) -> Context
pub fn as_raw(&self) -> NonNull<JSContext>
pub fn base(runtime: &Runtime) -> Result<Context, Error>
pub fn custom<I>(runtime: &Runtime) -> Result<Context, Error>
where I: Intrinsic,
pub fn full(runtime: &Runtime) -> Result<Context, Error>
pub fn builder() -> ContextBuilder<()>
pub fn runtime(&self) -> &Runtime
pub fn get_runtime_ptr(&self) -> *mut JSRuntime
pub fn with<F, R>(&self, f: F) -> R
where F: FnOnce(Ctx<'_>) -> R,
```

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

### starts_with

Source: https://docs.rs/rquickjs/latest/rquickjs/alloc/bstr/struct.ByteStr.html

Checks if the slice starts with the given needle.

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

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

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

### Creating Strings from Literals

Source: https://docs.rs/rquickjs/latest/rquickjs/alloc/string/index.html

Demonstrates multiple idiomatic ways to initialize a new String from string literals.

```rust
let s = "Hello".to_string();

let s = String::from("world");
let s: String = "also this".into();
```

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

### Throw message implementation

Source: https://docs.rs/rquickjs/latest/rquickjs/struct.Exception.html

Example of how throw_message is implemented internally.

```rust
let (Ok(e) | Err(e)) = Exception::from_message(ctx, message).map(|x| x.throw());
e
```

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

### Context::full

Source: https://docs.rs/rquickjs/latest/rquickjs/context/struct.Context.html

Creates a context with all standard available intrinsics registered.

```APIDOC
## pub fn full(runtime: &Runtime) -> Result<Context, Error>

### Description
Creates a context with all standard available intrinsics registered. If precise control is required of which functions are available use `Context::custom` or `Context::builder`.
```

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

### Deref Conversion

Source: https://docs.rs/rquickjs/latest/rquickjs/prelude/struct.Opt.html

Examples for coercing contents via Deref.

```rust
let x: Option<String> = Some("hey".to_owned());
assert_eq!(x.as_deref(), Some("hey"));

let x: Option<String> = None;
assert_eq!(x.as_deref(), None);
```

```rust
let mut x: Option<String> = Some("hey".to_owned());
assert_eq!(x.as_deref_mut().map(|x| {
    x.make_ascii_uppercase();
    x
}), Some("HEY".to_owned().as_mut_str()));
```

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

### ToOwned for RelativePath

Source: https://docs.rs/rquickjs/latest/rquickjs/alloc/borrow/trait.ToOwned.html

Example demonstrating the ToOwned implementation for RelativePath.

```rust
use relative_path::RelativePath;

let path = RelativePath::new("foo/bar").to_owned();
assert_eq!(path, "foo/bar");
```

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

### Basic format! macro usage

Source: https://docs.rs/rquickjs/latest/rquickjs/alloc/fmt/index.html

Examples of basic string formatting, including positional arguments, debug formatting, and named parameters.

```rust
format!("Hello");                 // => "Hello"
format!("Hello, {}!", "world");   // => "Hello, world!"
format!("The number is {}", 1);   // => "The number is 1"
format!("{:?}", (3, 4));          // => "(3, 4)"
format!("{value}", value=4);      // => "4"
let people = "Rustaceans";
format!("Hello {people}!");       // => "Hello Rustaceans!"
format!("{} {}", 1, 2);           // => "1 2"
format!("{:04}", 42);             // => "0042" with leading zeros
format!("{:#?}", (100, 200));     // => "(
                                  //       100,
                                  //       200,
                                  //     )"
```

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

### Create full context

Source: https://docs.rs/rquickjs/latest/rquickjs/context/struct.Context.html

Initializes a context with all standard intrinsics registered.

```rust
pub fn full(runtime: &Runtime) -> Result<Context, Error>
```

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

### Arc::weak_count

Source: https://docs.rs/rquickjs/latest/rquickjs/alloc/sync/struct.Arc.html

Gets the number of Weak pointers to the allocation.

```APIDOC
## pub fn weak_count(this: &Arc<T, A>) -> usize

### Description
Gets the number of `Weak` pointers to this allocation. Note that another thread can change the weak count at any time.
```

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

### Get associated runtime

Source: https://docs.rs/rquickjs/latest/rquickjs/context/struct.Context.html

Returns the runtime associated with the context.

```rust
pub fn runtime(&self) -> &Runtime
```

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

### Basic Formatting Parameters

Source: https://docs.rs/rquickjs/latest/rquickjs/alloc/fmt/index.html

Demonstrates basic usage of format specifiers for different types.

```rust
let a = 5;
let b = &a;
println!("{a:e} {b:p}"); // => 5e0 0x7ffe37b7273c
```

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

### Get slice length

Source: https://docs.rs/rquickjs/latest/rquickjs/alloc/bstr/struct.ByteString.html

Returns the number of elements in the slice.

```rust
let a = [1, 2, 3];
assert_eq!(a.len(), 3);
```

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

### Basic BTreeSet Operations

Source: https://docs.rs/rquickjs/latest/rquickjs/alloc/collections/btree_set/struct.BTreeSet.html

Demonstrates creating a BTreeSet, inserting elements, checking for existence, removing items, and iterating over the collection.

```rust
use std::collections::BTreeSet;

// Type inference lets us omit an explicit type signature (which
// would be `BTreeSet<&str>` in this example).
let mut books = BTreeSet::new();

// Add some books.
books.insert("A Dance With Dragons");
books.insert("To Kill a Mockingbird");
books.insert("The Odyssey");
books.insert("The Great Gatsby");

// Check for a specific one.
if !books.contains("The Winds of Winter") {
    println!("We have {} books, but The Winds of Winter ain't one.",
             books.len());
}

// Remove a book.
books.remove("The Odyssey");

// Iterate over everything.
for book in &books {
    println!("{book}");
}
```

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

### Rc::weak_count

Source: https://docs.rs/rquickjs/latest/rquickjs/alloc/rc/struct.Rc.html

Gets the number of Weak pointers to the allocation.

```APIDOC
## pub fn weak_count(this: &Rc<T, A>) -> usize

### Description
Gets the number of Weak pointers to this allocation.

### Parameters
- **this** (&Rc<T, A>) - Required - The Rc instance to query.
```

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

### Format NaiveDate with Display

Source: https://docs.rs/rquickjs/latest/rquickjs/alloc/fmt/trait.Display.html

Demonstrates how NaiveDate implements Display to produce ISO 8601 formatted strings.

```rust
use chrono::NaiveDate;

assert_eq!(format!("{}", NaiveDate::from_ymd_opt(2015, 9, 5).unwrap()), "2015-09-05");
assert_eq!(format!("{}", NaiveDate::from_ymd_opt(0, 1, 1).unwrap()), "0000-01-01");
assert_eq!(format!("{}", NaiveDate::from_ymd_opt(9999, 12, 31).unwrap()), "9999-12-31");
```

```rust
assert_eq!(format!("{}", NaiveDate::from_ymd_opt(-1, 1, 1).unwrap()), "-0001-01-01");
assert_eq!(format!("{}", NaiveDate::from_ymd_opt(10000, 12, 31).unwrap()), "+10000-12-31");
```

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

### iter

Source: https://docs.rs/rquickjs/latest/rquickjs/alloc/collections/btree_map/struct.BTreeMap.html

Gets an iterator over the entries of the map, sorted by key.

```APIDOC
## pub fn iter(&self) -> Iter<'_, K, V>

### Description
Gets an iterator over the entries of the map, sorted by key.
```

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

### Initialize BinaryHeap from Array

Source: https://docs.rs/rquickjs/latest/rquickjs/alloc/collections/binary_heap/struct.BinaryHeap.html

Shows how to create a BinaryHeap directly from an array of elements.

```rust
use std::collections::BinaryHeap;

let heap = BinaryHeap::from([1, 5, 2]);
```

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

### Using ThinBox for heap allocation

Source: https://docs.rs/rquickjs/latest/rquickjs/alloc/boxed/struct.ThinBox.html

Demonstrates creating ThinBox instances for sized and unsized types and verifying their pointer size.

```rust
#![feature(thin_box)]
use std::boxed::ThinBox;

let five = ThinBox::new(5);
let thin_slice = ThinBox::<[i32]>::new_unsize([1, 2, 3, 4]);

let size_of_ptr = size_of::<*const ()>();
assert_eq!(size_of_ptr, size_of_val(&five));
assert_eq!(size_of_ptr, size_of_val(&thin_slice));
```

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

### stream_position

Source: https://docs.rs/rquickjs/latest/rquickjs/alloc/io/struct.Take.html

Returns the current position of the cursor from the start of the stream.

```APIDOC
### fn stream_position(&mut self) -> Result<u64, Error>

Returns the current seek position from the start of the stream.
```

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

### Demonstrate ambiguous Pin conversion

Source: https://docs.rs/rquickjs/latest/rquickjs/alloc/boxed/struct.Box.html

Shows an example of a poor From implementation that causes ambiguity when calling Pin::from.

```rust
struct Foo; // A type defined in this crate.
impl From<Box<()>> for Pin<Foo> {
    fn from(_: Box<()>) -> Pin<Foo> {
        Pin::new(Foo)
    }
}

let foo = Box::new(());
let bar = Pin::from(foo);
```

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

### Creating an IntoIter

Source: https://docs.rs/rquickjs/latest/rquickjs/alloc/vec/struct.IntoIter.html

Demonstrates how to create an IntoIter instance from a vector.

```rust
let v = vec![0, 1, 2];
let iter: std::vec::IntoIter<_> = v.into_iter();
```

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

### Converting References

Source: https://docs.rs/rquickjs/latest/rquickjs/prelude/struct.Opt.html

Examples for converting Option<T> to references or mutable references.

```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:?}");
```

```rust
let mut x = Some(2);
match x.as_mut() {
    Some(v) => *v = 42,
    None => {},
}
assert_eq!(x, Some(42));
```

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

### Splitting the last element

Source: https://docs.rs/rquickjs/latest/rquickjs/alloc/bstr/struct.ByteString.html

Examples of removing the last element from a slice.

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

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

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

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

### Constructing a Box from a NonNull pointer

Source: https://docs.rs/rquickjs/latest/rquickjs/alloc/boxed/struct.Box.html

Examples demonstrating how to recreate a Box from a NonNull pointer or manually allocate memory and initialize it for a Box.

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

use std::alloc::System;

let x = Box::new_in(5, System);
let (non_null, alloc) = Box::into_non_null_with_allocator(x);
let x = unsafe { Box::from_non_null_in(non_null, alloc) };
```

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

use std::alloc::{Allocator, Layout, System};

unsafe {
    let non_null = System.allocate(Layout::new::<i32>())?.cast::<i32>();
    // In general .write is required to avoid attempting to destruct
    // the (uninitialized) previous contents of `non_null`.
    non_null.write(5);
    let x = Box::from_non_null_in(non_null, System);
}
```

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

### Splitting the first element

Source: https://docs.rs/rquickjs/latest/rquickjs/alloc/bstr/struct.ByteString.html

Examples of removing the first element from a slice.

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

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

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

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

### Initialize a new BinaryHeap

Source: https://docs.rs/rquickjs/latest/rquickjs/alloc/collections/binary_heap/struct.BinaryHeap.html

Create an empty max-heap using the default allocator.

```rust
use std::collections::BinaryHeap;
let mut heap = BinaryHeap::new();
heap.push(4);
```

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

### Flattening nested Results

Source: https://docs.rs/rquickjs/latest/rquickjs/alloc/io/type.Result.html

Examples of flattening nested Result types.

```rust
let x: Result<Result<&'static str, u32>, u32> = Ok(Ok("hello"));
assert_eq!(Ok("hello"), x.flatten());

let x: Result<Result<&'static str, u32>, u32> = Ok(Err(6));
assert_eq!(Err(6), x.flatten());

let x: Result<Result<&'static str, u32>, u32> = Err(6);
assert_eq!(Err(6), x.flatten());
```

```rust
let x: Result<Result<Result<&'static str, u32>, u32>, u32> = Ok(Ok(Ok("hello")));
assert_eq!(Ok(Ok("hello")), x.flatten());
assert_eq!(Ok("hello"), x.flatten().flatten());
```

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

### Basic BinaryHeap Operations

Source: https://docs.rs/rquickjs/latest/rquickjs/alloc/collections/binary_heap/struct.BinaryHeap.html

Demonstrates standard heap operations including initialization, pushing, peeking, checking length, iteration, and clearing.

```rust
use std::collections::BinaryHeap;

// Type inference lets us omit an explicit type signature (which
// would be `BinaryHeap<i32>` in this example).
let mut heap = BinaryHeap::new();

// We can use peek to look at the next item in the heap. In this case,
// there's no items in there yet so we get None.
assert_eq!(heap.peek(), None);

// Let's add some scores...
heap.push(1);
heap.push(5);
heap.push(2);

// Now peek shows the most important item in the heap.
assert_eq!(heap.peek(), Some(&5));

// We can check the length of a heap.
assert_eq!(heap.len(), 3);

// We can iterate over the items in the heap, although they are returned in
// a random order.
for x in &heap {
    println!("{x}");
}

// If we instead pop these scores, they should come back in order.
assert_eq!(heap.pop(), Some(5));
assert_eq!(heap.pop(), Some(2));
assert_eq!(heap.pop(), Some(1));
assert_eq!(heap.pop(), None);

// We can clear the heap of any remaining items.
heap.clear();

// The heap should now be empty.
assert!(heap.is_empty())
```

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

### match_indices<P>(&self, pat: P) -> MatchIndices<'_, P>

Source: https://docs.rs/rquickjs/latest/rquickjs/struct.CString.html

Returns an iterator over the disjoint matches of a pattern within this string slice as well as the index that the match starts at.

```APIDOC
## match_indices<P>(&self, pat: P) -> MatchIndices<'_, P>

### Description
Returns an iterator over the disjoint matches of a pattern within this string slice as well as the index that the match starts at. For matches that overlap, only the indices corresponding to the first match are returned.

### Parameters
- **pat** (P) - Required - The pattern to search for.
```

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

### Get string capacity

Source: https://docs.rs/rquickjs/latest/rquickjs/alloc/string/struct.String.html

Returns the current capacity of the String in bytes.

```rust
let s = String::with_capacity(10);

assert!(s.capacity() >= 10);
```

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

### Consuming a Box into a raw pointer

Source: https://docs.rs/rquickjs/latest/rquickjs/alloc/boxed/struct.Box.html

Examples showing how to consume a Box into a raw pointer and allocator, then either restoring it or performing manual cleanup.

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

use std::alloc::System;

let x = Box::new_in(String::from("Hello"), System);
let (ptr, alloc) = Box::into_raw_with_allocator(x);
let x = unsafe { Box::from_raw_in(ptr, alloc) };
```

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

use std::alloc::{Allocator, Layout, System};
use std::ptr::{self, NonNull};

let x = Box::new_in(String::from("Hello"), System);
let (ptr, alloc) = Box::into_raw_with_allocator(x);
unsafe {
    ptr::drop_in_place(ptr);
    let non_null = NonNull::new_unchecked(ptr);
    alloc.deallocate(non_null.cast(), Layout::new::<String>());
}
```

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

### Get Cell value

Source: https://docs.rs/rquickjs/latest/rquickjs/function/struct.OnceFn.html

Retrieves a copy of the value stored in the Cell.

```rust
use std::cell::Cell;

let c = Cell::new(5);

let five = c.get();
```

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

### Manually Create Box from Global Allocator

Source: https://docs.rs/rquickjs/latest/rquickjs/runtime/type.RejectionTracker.html

Shows how to allocate memory manually and wrap it in a Box using the global allocator.

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

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

### Verify Option Product Behavior

Source: https://docs.rs/rquickjs/latest/rquickjs/qjs/type.JSHostPromiseRejectionTracker.html

Demonstrates how the product of an iterator of Options behaves when an underflow or invalid value occurs.

```rust
assert_eq!(res, None);
assert_eq!(shared, 6);
```

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

### get<I>

Source: https://docs.rs/rquickjs/latest/rquickjs/alloc/bstr/struct.ByteStr.html

Returns a reference to an element or subslice depending on the type of index.

```APIDOC
## get<I>

### Description
Returns a reference to an element or subslice depending on the type of index. If given a position, returns a reference to the element at that position or `None` if out of bounds. If given a range, returns the subslice corresponding to that range, or `None` if out of bounds.
```

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

### Get vector length

Source: https://docs.rs/rquickjs/latest/rquickjs/alloc/bstr/struct.ByteString.html

Returns the number of elements currently in the vector.

```rust
let a = vec![1, 2, 3];
assert_eq!(a.len(), 3);
```

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

### Initialize BTreeMap from Array

Source: https://docs.rs/rquickjs/latest/rquickjs/alloc/collections/btree_map/struct.BTreeMap.html

Shows how to initialize a BTreeMap using an array of key-value pairs.

```rust
use std::collections::BTreeMap;

let solar_distance = BTreeMap::from([
    ("Mercury", 0.4),
    ("Venus", 0.7),
    ("Earth", 1.0),
    ("Mars", 1.5),
]);
```

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

### Rc::strong_count

Source: https://docs.rs/rquickjs/latest/rquickjs/alloc/rc/struct.Rc.html

Gets the number of strong Rc pointers to the allocation.

```APIDOC
## pub fn strong_count(this: &Rc<T, A>) -> usize

### Description
Gets the number of strong (Rc) pointers to this allocation.

### Parameters
- **this** (&Rc<T, A>) - Required - The Rc instance to query.
```

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

### Basic usage of UpperExp with f64

Source: https://docs.rs/rquickjs/latest/rquickjs/alloc/fmt/trait.UpperExp.html

Demonstrates formatting a float using the :E format specifier.

```rust
let x = 42.0; // 42.0 is '4.2E1' in scientific notation

assert_eq!(format!("{x:E}"), "4.2E1");
```

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

### Get the length of a LinkedList

Source: https://docs.rs/rquickjs/latest/rquickjs/alloc/collections/linked_list/struct.LinkedList.html

Retrieve the number of elements currently in the list.

```rust
use std::collections::LinkedList;

let mut dl = LinkedList::new();

dl.push_front(2);
assert_eq!(dl.len(), 1);

dl.push_front(1);
assert_eq!(dl.len(), 2);

dl.push_back(3);
assert_eq!(dl.len(), 3);
```

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

### Initialize a BinaryHeap with a custom allocator

Source: https://docs.rs/rquickjs/latest/rquickjs/alloc/collections/binary_heap/struct.BinaryHeap.html

Create a heap using a specific allocator, requiring the allocator_api feature.

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

use std::alloc::System;
use std::collections::BinaryHeap;

let heap : BinaryHeap<i32, System> = BinaryHeap::new_in(System);
```

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

use std::alloc::System;
use std::collections::BinaryHeap;

let heap: BinaryHeap<i32, System> = BinaryHeap::with_capacity_in(10, System);
```

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

### iter_mut

Source: https://docs.rs/rquickjs/latest/rquickjs/alloc/collections/btree_map/struct.BTreeMap.html

Gets a mutable iterator over the entries of the map, sorted by key.

```APIDOC
## pub fn iter_mut(&mut self) -> IterMut<'_, K, V>

### Description
Gets a mutable iterator over the entries of the map, sorted by key.
```

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

### Create base context

Source: https://docs.rs/rquickjs/latest/rquickjs/context/struct.Context.html

Initializes a context with only the minimum required functions.

```rust
pub fn base(runtime: &Runtime) -> Result<Context, Error>
```

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

### Write module bytecode

Source: https://docs.rs/rquickjs/latest/rquickjs/module/struct.Module.html

Demonstrates how to declare a module and serialize it into bytecode using specified write options.

```rust
use rquickjs::{Context, Module, Result, Runtime, WriteOptions, WriteOptionsEndianness};
fn main() -> Result<()> {
    let rt = Runtime::new()?;
    let ctx = Context::full(&rt)?;
    let bytecode = ctx.with(|ctx| {
        let src = "console.log('hello world')";
        let module = Module::declare(ctx.clone(), "foo.js", src)?;
        module.write(WriteOptions {
            endianness: WriteOptionsEndianness::Little,
            ..Default::default()
        })
    })?;
    println!("bytecode: {bytecode:?}");
    Ok(())
}
```

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

### Get a reference to an element

Source: https://docs.rs/rquickjs/latest/rquickjs/alloc/collections/btree_set/struct.BTreeSet.html

Returns a reference to the element in the set if it exists.

```rust
use std::collections::BTreeSet;

let set = BTreeSet::from([1, 2, 3]);
assert_eq!(set.get(&2), Some(&2));
assert_eq!(set.get(&4), None);
```

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

### iter()

Source: https://docs.rs/rquickjs/latest/rquickjs/alloc/vec/struct.Vec.html

Returns an iterator over the slice, yielding all items from start to end.

```APIDOC
## pub fn iter(&self) -> Iter<'_, T>

### Description
Returns an iterator over the slice. The iterator yields all items from start to end.
```

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

### Format strings with different types and alignment

Source: https://docs.rs/rquickjs/latest/rquickjs/alloc/fmt/index.html

Examples showing how precision affects fractional digits, string truncation, and alignment.

```rust
println!("{}, `{name:.*}` has 3 fractional digits", "Hello", 3, name=1234.56);
println!("{}, `{name:.*}` has 3 characters", "Hello", 3, name="1234.56");
println!("{}, `{name:>8.*}` has 3 right-aligned characters", "Hello", 3, name="1234.56");
```

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

### Create a Vec with the vec! macro

Source: https://docs.rs/rquickjs/latest/rquickjs/alloc/vec/index.html

Demonstrates initializing vectors using the vec! macro with various initial states.

```rust
let v: Vec<i32> = vec![];

let v = vec![1, 2, 3, 4, 5];

let v = vec![0; 10]; // ten zeroes
```

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

### Basic Binary Formatting

Source: https://docs.rs/rquickjs/latest/rquickjs/alloc/fmt/trait.Binary.html

Demonstrates formatting integers as binary strings and using the alternate flag for a 0b prefix.

```rust
let x = 42; // 42 is '101010' in binary

assert_eq!(format!("{x:b}"), "101010");
assert_eq!(format!("{x:#b}"), "0b101010");

assert_eq!(format!("{:b}", -16), "11111111111111111111111111110000");
```

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

### Aliasing guarantee for as_non_null

Source: https://docs.rs/rquickjs/latest/rquickjs/alloc/vec/struct.Vec.html

Placeholder for aliasing examples using the as_non_null feature.

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

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

### Strip circumfix examples

Source: https://docs.rs/rquickjs/latest/rquickjs/alloc/string/struct.String.html

Removes both a prefix and a suffix exactly once if both are present and do not overlap.

```rust
assert_eq!("bar:hello:foo".strip_circumfix("bar:", ":foo"), Some("hello"));
assert_eq!("bar:foo".strip_circumfix("foo", "foo"), None);
assert_eq!("foo:bar;".strip_circumfix("foo:", ';'), Some("bar"));
assert_eq!("foo:bar:baz".strip_circumfix("foo:bar:", ":bar:baz"), None);
```

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

### take

Source: https://docs.rs/rquickjs/latest/rquickjs/alloc/collections/binary_heap/struct.IntoIter.html

Creates an iterator that yields the first n elements.

```APIDOC
## fn take(self, n: usize) -> Take<Self>

### Description
Creates an iterator that yields the first `n` elements, or fewer if the underlying iterator ends sooner.
```

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

### Strip suffix examples

Source: https://docs.rs/rquickjs/latest/rquickjs/alloc/string/struct.String.html

Removes a suffix exactly once if present, returning an Option.

```rust
assert_eq!("bar:foo".strip_suffix(":foo"), Some("bar"));
assert_eq!("bar:foo".strip_suffix("bar"), None);
assert_eq!("foofoo".strip_suffix("foo"), Some("foo"));
```

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

### Fill and Alignment Formatting

Source: https://docs.rs/rquickjs/latest/rquickjs/alloc/fmt/index.html

Demonstrates how to use fill characters and alignment specifiers to pad output.

```rust
assert_eq!(format!("Hello {:<5}!", "x"),  "Hello x    !");
assert_eq!(format!("Hello {:-<5}!", "x"), "Hello x----!");
assert_eq!(format!("Hello {:^5}!", "x"),  "Hello   x  !");
assert_eq!(format!("Hello {:>5}!", "x"),  "Hello     x!");
```

```rust
println!("Hello {:^15}!", format!("{:?}", Some("hi"))); // => "Hello   Some("hi")   !"
```
Tokens:
Raw