Knuffel

https://docs.rs/knuffel/3.2.0/knuffel/
Admin
Knuffel is a Rust KDL file format parser with excellent error reporting and convenient derive macros...
Tokens:59,464
Snippets:532
Trust Score:9.1
Update:6 months ago
Show doc for...
Tokens:
Raw
### KDL File Format Example

Source: https://docs.rs/knuffel

Illustrates the basic structure of a KDL file, including nodes, arguments, properties, and children.

```kdl
foo 1 key="val" "three" {
    bar
    (role)baz 1 2
}
```

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

### Check string prefix

Source: https://docs.rs/knuffel/3.2.0/knuffel/ast/struct.TypeName.html

Verifies if a string slice starts with a given pattern or character slice.

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

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

### Parse Nodes with Default Values

Source: https://docs.rs/knuffel/3.2.0/knuffel/derive.Decode.html

Example of how null and missing properties interact with default values.

```text
node name=null
node
```

```rust
let _ = vec![
    MyNode { name: None },
    MyNode { name: Some(String::from("unnamed")) },
];
```

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

### Define KDL Nodes

Source: https://docs.rs/knuffel/3.2.0/knuffel/derive.Decode.html

Basic example of KDL node hierarchy including types and nested children.

```KDL
node1 "x" "y"
(my_type)node2 prop="value" {
    node3 1
    node4 2
}
```

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

### Trim ASCII Start

Source: https://docs.rs/knuffel/3.2.0/knuffel/ast/struct.TypeName.html

Removes leading ASCII whitespace from a string slice.

```rust
assert_eq!(" \t \u{3000}hello world\n".trim_ascii_start(), "\u{3000}hello world\n");
assert_eq!("  ".trim_ascii_start(), "");
assert_eq!("".trim_ascii_start(), "");
```

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

### Parse KDL with context

Source: https://docs.rs/knuffel/3.2.0/knuffel/fn.parse_with_context.html

Parses KDL text and decodes it into a Rust object using a provided context setup function.

```rust
pub fn parse_with_context<T, S, F>(
    file_name: &str,
    text: &str,
    set_ctx: F,
) -> Result<T, Error>
where
    F: FnOnce(&mut Context<S>),
    T: DecodeChildren<S>,
    S: Span,
```

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

### Parse Children Nodes

Source: https://docs.rs/knuffel/3.2.0/knuffel/derive.Decode.html

Example of mapping a KDL node with children to Rust structures using child and children attributes.

```KDL
node {
    version 1
    plugin "xxx"
    datum "yyy"
}
```

```Rust
#[derive(knuffel::Decode)]
enum Setting {
    Plugin(#[knuffel(argument)] String),
    Datum(#[knuffel(argument)] String),
}
#[derive(knuffel::Decode)]
struct Version {
    #[knuffel(argument)]
    number: u32
}
#[derive(knuffel::Decode)]
struct MyNode {
    #[knuffel(child)]
    version: Version,
    #[knuffel(children)]
    settings: Vec<Setting>
}
```

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

### Implement Error for Error (description method - Deprecated)

Source: https://docs.rs/knuffel/3.2.0/knuffel/errors/struct.Error.html

Deprecated method for getting a string description of the error. Use the Display impl or to_string() instead.

```rust
fn description(&self) -> &str
```

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

### Get String Representation of BuiltinType

Source: https://docs.rs/knuffel/3.2.0/knuffel/ast/enum.BuiltinType.html

Returns the string representation of a BuiltinType variant as defined by the KDL specification. This method is useful for serializing or displaying the type.

```rust
pub const fn as_str(&self) -> &'static str
```

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

### Find indices of all pattern matches

Source: https://docs.rs/knuffel/3.2.0/knuffel/ast/struct.TypeName.html

Use `match_indices` to get an iterator over the starting indices and the matched string slices for all disjoint occurrences of a pattern. Overlapping matches are not included.

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

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

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

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

### pub fn starts_with<P>(&self, pat: P) -> bool

Source: https://docs.rs/knuffel/3.2.0/knuffel/ast/struct.TypeName.html

Returns true if the given pattern matches a prefix of this string slice.

```APIDOC
## starts_with

### Description
Returns true if the given pattern matches a prefix of this string slice. Returns false if it does not.

### Parameters
- **pat** (Pattern) - Required - The pattern to check as a prefix.
```

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

### Find indices of pattern matches in reverse

Source: https://docs.rs/knuffel/3.2.0/knuffel/ast/struct.TypeName.html

Use `rmatch_indices` to get an iterator over the starting indices and the matched string slices for all disjoint occurrences of a pattern, yielded in reverse order. Overlapping matches are not included.

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

```rust
let v: Vec<_> = "1abc2abc3".rmatch_indices(char::is_numeric).collect();
assert_eq!(v, [(6, "3"), (4, "2"), (0, "1")]);
```

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

### Check for Character Boundary in String Slice

Source: https://docs.rs/knuffel/3.2.0/knuffel/ast/struct.TypeName.html

Verifies if a given byte index is the start of a UTF-8 character sequence or the end of the string. The start and end of the string are considered boundaries. Returns false if the index is out of bounds.

```rust
let s = "Löwe 老虎 Léopard";
assert!(s.is_char_boundary(0));
// start of `老`
assert!(s.is_char_boundary(6));
assert!(s.is_char_boundary(s.len()));

// second byte of `ö`
assert!(!s.is_char_boundary(2));

// third byte of `老`
assert!(!s.is_char_boundary(8));
```

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

### Split string slice by patterns

Source: https://docs.rs/knuffel/3.2.0/knuffel/ast/struct.TypeName.html

Demonstrates splitting strings using characters, string slices, closures, and slices of characters.

```rust
let v: Vec<&str> = "Mary had a little lamb".split(' ').collect();
assert_eq!(v, ["Mary", "had", "a", "little", "lamb"]);

let v: Vec<&str> = "".split('X').collect();
assert_eq!(v, [""]);

let v: Vec<&str> = "lionXXtigerXleopard".split('X').collect();
assert_eq!(v, ["lion", "", "tiger", "leopard"]);

let v: Vec<&str> = "lion::tiger::leopard".split("::").collect();
assert_eq!(v, ["lion", "tiger", "leopard"]);

let v: Vec<&str> = "AABBCC".split("DD").collect();
assert_eq!(v, ["AABBCC"]);

let v: Vec<&str> = "abc1def2ghi".split(char::is_numeric).collect();
assert_eq!(v, ["abc", "def", "ghi"]);

let v: Vec<&str> = "lionXtigerXleopard".split(char::is_uppercase).collect();
assert_eq!(v, ["lion", "tiger", "leopard"]);
```

```rust
let v: Vec<&str> = "2020-11-03 23:59".split(&['-', ' ', ':', '@'][..]).collect();
assert_eq!(v, ["2020", "11", "03", "23", "59"]);
```

```rust
let v: Vec<&str> = "abc1defXghi".split(|c| c == '1' || c == 'X').collect();
assert_eq!(v, ["abc", "def", "ghi"]);
```

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

### Implement CloneToUninit (Nightly)

Source: https://docs.rs/knuffel/3.2.0/knuffel/ast/struct.Decimal.html

An experimental, nightly-only API for performing copy-assignment from a cloned value to an uninitialized memory location.

```rust
unsafe fn clone_to_uninit(&self, dest: *mut u8)
```

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

### Implement Diagnostic for Error (help method)

Source: https://docs.rs/knuffel/3.2.0/knuffel/errors/struct.Error.html

Provides additional help text related to the diagnostic.

```rust
fn help<'a>(&'a self) -> Option<Box<dyn Display + 'a>>
```

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

### Struct Span

Source: https://docs.rs/knuffel/3.2.0/knuffel/span/struct.Span.html

Represents a normal byte offset span with a start and end position.

```APIDOC
## Struct Span

knuffel::span

### Summary
```rust
pub struct Span(pub usize, pub usize);
```

### Description
Normal byte offset span

### Tuple Fields
- `0: usize`
- `1: usize`

### Implementations
#### impl Span
##### pub fn length(&self) -> usize
Length of the span in bytes
```

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

### Get Span from Spanned

Source: https://docs.rs/knuffel/3.2.0/knuffel/span/struct.Spanned.html

Returns an immutable reference to the span associated with the Spanned value.

```rust
pub fn span(&self) -> &S
```

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

### pub fn trim_ascii_start(&self) -> &str

Source: https://docs.rs/knuffel/3.2.0/knuffel/ast/struct.TypeName.html

Returns a string slice with leading ASCII whitespace removed.

```APIDOC
## trim_ascii_start

### Description
Returns a string slice with leading ASCII whitespace removed, based on `u8::is_ascii_whitespace`.

### Response
- **&str** - The trimmed string slice.
```

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

### rsplitn

Source: https://docs.rs/knuffel/3.2.0/knuffel/ast/struct.TypeName.html

Returns an iterator over substrings separated by a pattern, starting from the end, restricted to at most n items.

```APIDOC
## rsplitn

### Description
Returns an iterator over substrings of this string slice, separated by a pattern, starting from the end of the string, restricted to returning at most n items. If n substrings are returned, the last substring will contain the remainder of the string.

### Parameters
- **n** (usize) - Required - The maximum number of items to return.
- **pat** (Pattern) - Required - The pattern to split by (must support reverse search).
```

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

### SourceSpan Implementations

Source: https://docs.rs/knuffel/3.2.0/knuffel/span/struct.ErrorSpan.html

Provides methods for creating and manipulating SourceSpan objects.

```APIDOC
## Implementations

### impl SourceSpan

#### pub const fn new(start: SourceOffset, length: SourceOffset) -> SourceSpan

Create a new `SourceSpan`.

#### pub const fn offset(&self) -> usize

The absolute offset, in bytes, from the beginning of a `SourceCode`.

#### pub const fn len(&self) -> usize

Total length of the `SourceSpan`, in bytes.

#### pub const fn is_empty(&self) -> bool

Whether this `SourceSpan` has a length of zero. It may still be useful to point to a specific point.
```

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

### Derive Macros

Source: https://docs.rs/knuffel/3.2.0/knuffel/index.html

Derive macros for simplifying Rust object decoding from KDL.

```APIDOC
## Derive Macros

### Decode

#### Description
The derive is the most interesting part of the `knuffel` library.

### Method
Not specified (used as an attribute in Rust code)

### Endpoint
N/A

### Parameters
N/A

### Request Example
N/A

### Response
N/A

### DecodeScalar

#### Description
Currently `DecodeScalar` derive is only implemented for enums.

### Method
Not specified (used as an attribute in Rust code)

### Endpoint
N/A

### Parameters
N/A

### Request Example
N/A

### Response
N/A
```

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

### Implement Diagnostic for Error (url method)

Source: https://docs.rs/knuffel/3.2.0/knuffel/errors/struct.Error.html

Provides a URL for more detailed explanation or help about the diagnostic.

```rust
fn url<'a>(&'a self) -> Option<Box<dyn Display + 'a>>
```

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

### Any Trait Implementation

Source: https://docs.rs/knuffel/3.2.0/knuffel/ast/struct.Value.html

Provides the `type_id` method to get the `TypeId` of the value. This is part of the blanket implementation for `Any`.

```rust
impl<T> Any for T
where T: 'static + ?Sized,
{
    fn type_id(&self) -> TypeId
}
```

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

### Iterate over lines in a string

Source: https://docs.rs/knuffel/3.2.0/knuffel/ast/struct.TypeName.html

Demonstrates how to split a string into lines, noting that trailing carriage returns are included in the last line if present.

```rust
let text = "foo\r\nbar\n\nbaz\r";
let mut lines = text.lines();

assert_eq!(Some("foo"), lines.next());
assert_eq!(Some("bar"), lines.next());
assert_eq!(Some(""), lines.next());
// Trailing carriage return is included in the last line
assert_eq!(Some("baz\r"), lines.next());

assert_eq!(None, lines.next());
```

```rust
let text = "foo\nbar\n\r\nbaz";
let mut lines = text.lines();

assert_eq!(Some("foo"), lines.next());
assert_eq!(Some("bar"), lines.next());
assert_eq!(Some(""), lines.next());
assert_eq!(Some("baz"), lines.next());

assert_eq!(None, lines.next());
```

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

### Define a Node with Properties

Source: https://docs.rs/knuffel/3.2.0/knuffel/derive.Decode.html

Demonstrates mapping KDL properties to a Rust struct using the property and properties attributes.

```text
node name="arg1" enabled=true a=1 b=2 c=3
```

```rust
#[derive(knuffel::Decode)]
struct MyNode {
    #[knuffel(property)]
    name: String,
    #[knuffel(property)]
    enabled: bool,
    #[knuffel(properties)]
    numbers: HashMap<String, u32>,
}
```

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

### Implement Chain for Generic Type T

Source: https://docs.rs/knuffel/3.2.0/knuffel/ast/struct.Decimal.html

Provides methods to get the length and append elements for a chainable type `T`.

```rust
fn len(&self) -> usize
```

```rust
fn append_to(self, v: &mut Vec<T>)
```

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

### SourceSpan Trait Implementations

Source: https://docs.rs/knuffel/3.2.0/knuffel/span/struct.ErrorSpan.html

Details the various traits implemented for SourceSpan, including Clone, Debug, From, Hash, PartialEq, Eq, and others.

```APIDOC
## Trait Implementations

### impl Clone for SourceSpan

#### fn clone(&self) -> SourceSpan

Returns a duplicate of the value.

#### fn clone_from(&mut self, source: &Self)

Performs copy-assignment from `source`.

### impl Debug for SourceSpan

#### fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

Formats the value using the given formatter.

### impl From<(SourceOffset, SourceOffset)> for SourceSpan

#### fn from(_: (SourceOffset, SourceOffset)) -> SourceSpan

Converts to this type from the input type.

### impl From<(usize, usize)> for SourceSpan

#### fn from(_: (usize, usize)) -> SourceSpan

Converts to this type from the input type.

### impl From<Range<usize>> for SourceSpan

#### fn from(range: Range<usize>) -> SourceSpan

Converts to this type from the input type.

### impl From<SourceOffset> for SourceSpan

#### fn from(offset: SourceOffset) -> SourceSpan

Converts to this type from the input type.

### impl From<usize> for SourceSpan

#### fn from(offset: usize) -> SourceSpan

Converts to this type from the input type.

### impl Hash for SourceSpan

#### fn hash<__H>(&self, state: &mut __H)

where __H: Hasher,
Feeds this value into the given `Hasher`.

#### fn hash_slice<H>(data: &[Self], state: &mut H)

where H: Hasher, Self: Sized,
Feeds a slice of this type into the given `Hasher`.

### impl Into<SourceSpan> for LineSpan

#### fn into(self) -> ErrorSpan

Converts this type into the (usually inferred) input type.

### impl Into<SourceSpan> for Span

#### fn into(self) -> ErrorSpan

Converts this type into the (usually inferred) input type.

### impl PartialEq for SourceSpan

#### fn eq(&self, other: &SourceSpan) -> bool

Tests for `self` and `other` values to be equal, and is used by `==`.

#### fn ne(&self, other: &Rhs) -> bool

Tests for `!=`.

### impl Copy for SourceSpan

### impl Eq for SourceSpan

### impl StructuralPartialEq for SourceSpan

## Auto Trait Implementations

### impl Freeze for SourceSpan

### impl RefUnwindSafe for SourceSpan

### impl Send for SourceSpan

### impl Sync for SourceSpan

### impl Unpin for SourceSpan

### impl UnwindSafe for SourceSpan

## Blanket Implementations

### impl<T> Any for T

where T: 'static + ?Sized,

#### fn type_id(&self) -> TypeId

Gets the `TypeId` of `self`.

### impl<T> Borrow<T> for T

where T: ?Sized,

#### fn borrow(&self) -> &T

Immutably borrows from an owned value.

### impl<T> BorrowMut<T> for T

where T: ?Sized,

#### fn borrow_mut(&mut self) -> &mut T

Mutably borrows from an owned value.

### impl<T> Chain<T> for T

#### fn len(&self) -> usize

The number of items that this chain link consists of.

#### fn append_to(self, v: &mut Vec<T>)

Append the elements in this link to the chain.

### impl<T> CloneToUninit for T

where T: Clone,

#### unsafe fn clone_to_uninit(&self, dest: *mut u8)

Performs copy-assignment from `self` to `dest`.

### impl<T> Container<T> for T

where T: Clone,

#### type Iter = Once<T>

An iterator over the items within this container, by value.

#### fn get_iter(&self) -> <T as Container<T>>::Iter

Iterate over the elements of the container (using internal iteration because GATs are unstable).

### impl<T> DecodeSpan<T> for T

where T: ErrorSpan,

#### fn decode_span(span: &T, _: &mut Context<T>) -> T

Decode span.

### impl<Q, K> Equivalent<K> for Q

where Q: Eq + ?Sized, K: Borrow<Q> + ?Sized,

#### fn equivalent(&self, key: &K) -> bool

Checks if this value is equivalent to the given key.

### impl<T> From<T> for T

```

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

### KDL Syntax Annotation

Source: https://docs.rs/knuffel

Provides a visual breakdown of KDL syntax elements like node names, arguments, properties, and types.

```kdl
foo 1 "three" key="val" {
─┬─ ┬ ───┬─── ────┬────
 │  │    │        ╰───── property (can be multiple)
 │  │    │
 │  ╰────┴────────────── arguments
 │
 └── node name
    bar
    (role)baz 1 2
     ──┬─
       └────── type name for node named "baz"
}
```

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

### match_indices

Source: https://docs.rs/knuffel/3.2.0/knuffel/ast/struct.TypeName.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

### 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 overlapping matches, only the first match is returned.

### Parameters
#### Path Parameters
- **pat** (Pattern) - Required - The pattern to match against the string.

### Response
#### Success Response (200)
- **MatchIndices<'_, P>** - An iterator yielding tuples of (index, match_string).
```

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

### Implement Error for Error (cause method - Deprecated)

Source: https://docs.rs/knuffel/3.2.0/knuffel/errors/struct.Error.html

Deprecated method for getting the cause of the error. Replaced by Error::source.

```rust
fn cause(&self) -> Option<&dyn Error>
```

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

### Conversion Traits (TryFrom/TryInto)

Source: https://docs.rs/knuffel/3.2.0/knuffel/span/struct.Span.html

Documentation for the TryFrom and TryInto traits used for fallible conversions between types.

```APIDOC
## Trait: TryFrom<U>

### Description
Performs a fallible conversion from type U to type T.

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

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

## Trait: TryInto<U>

### Description
Performs a fallible conversion from the current type to type U.

### Associated Types
- **Error** (<U as TryFrom<T>>::Error) - The type returned in the event of a conversion error.

### Methods
- **try_into(self) -> Result<U, Self::Error>** - Performs the conversion.
```

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

### Get Iterator for Container in Rust

Source: https://docs.rs/knuffel/3.2.0/knuffel/ast/struct.Node.html

Provides an iterator over the elements within the container. This uses internal iteration as GATs are unstable.

```rust
fn get_iter(&self) -> <T as Container<T>>::Iter
```

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

### Generic Blanket Implementations

Source: https://docs.rs/knuffel/3.2.0/knuffel/span/struct.Spanned.html

This section covers various blanket implementations for generic types, including Any, Borrow, BorrowMut, Chain, CloneToUninit, Container, Equivalent, From, Into, Receiver, ToOwned, TryFrom, TryInto, and OrderedContainer.

```APIDOC
## impl<T> Any for T

where T: 'static + ?Sized,

### Description
Provides blanket implementation for the `Any` trait.

#### fn type_id(&self) -> TypeId

##### Description
Gets the `TypeId` of `self`.

## impl<T> Borrow<T> for T

where T: ?Sized,

### Description
Provides blanket implementation for the `Borrow` trait.

#### fn borrow(&self) -> &T

##### Description
Immutably borrows from an owned value.

## impl<T> BorrowMut<T> for T

where T: ?Sized,

### Description
Provides blanket implementation for the `BorrowMut` trait.

#### fn borrow_mut(&mut self) -> &mut T

##### Description
Mutably borrows from an owned value.

## impl<T> Chain<T> for T

### Description
Provides blanket implementation for the `Chain` trait.

#### fn len(&self) -> usize

##### Description
The number of items that this chain link consists of.

#### fn append_to(self, v: &mut Vec<T>)

##### Description
Append the elements in this link to the chain.

## impl<T> CloneToUninit for T

where T: Clone,

### Description
Provides blanket implementation for the `CloneToUninit` trait (nightly-only).

#### unsafe fn clone_to_uninit(&self, dest: *mut u8)

##### Description
Performs copy-assignment from `self` to `dest`.

## impl<T> Container<T> for T

where T: Clone,

### Description
Provides blanket implementation for the `Container` trait.

#### type Iter = Once<T>

##### Description
An iterator over the items within this container, by value.

#### fn get_iter(&self) -> <T as Container<T>>::Iter

##### Description
Iterate over the elements of the container (using internal iteration because GATs are unstable).

## impl<Q, K> Equivalent<K> for Q

where Q: Eq + ?Sized, K: Borrow<Q> + ?Sized,

### Description
Provides blanket implementation for the `Equivalent` trait.

#### fn equivalent(&self, key: &K) -> bool

##### Description
Checks if this value is equivalent to the given key.

## impl<T> From<T> for T

### Description
Provides blanket implementation for the `From` trait.

#### fn from(t: T) -> T

##### Description
Returns the argument unchanged.

## impl<T, U> Into<U> for T

where U: From<T>,

### Description
Provides blanket implementation for the `Into` trait.

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

##### Description
Calls `U::from(self)`.

## impl<P, T> Receiver for P

where P: Deref<Target = T> + ?Sized, T: ?Sized,

### Description
Provides blanket implementation for the `Receiver` trait (nightly-only).

#### type Target = T

##### Description
The target type on which the method may be called.

## impl<T> ToOwned for T

where T: Clone,

### Description
Provides blanket implementation for the `ToOwned` trait.

#### type Owned = T

##### Description
The resulting type after obtaining ownership.

#### fn to_owned(&self) -> T

##### Description
Creates owned data from borrowed data, usually by cloning.

#### fn clone_into(&self, target: &mut T)

##### Description
Uses borrowed data to replace owned data, usually by cloning.

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

where U: Into<T>,

### Description
Provides blanket implementation for the `TryFrom` trait.

#### type Error = Infallible

##### Description
The type returned in the event of a conversion error.

#### fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>

##### Description
Performs the conversion.

## impl<T, U> TryInto<U> for T

where U: TryFrom<T>,

### Description
Provides blanket implementation for the `TryInto` trait.

#### type Error = <U as TryFrom<T>>::Error

##### Description
The type returned in the event of a conversion error.

#### fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>

##### Description
Performs the conversion.

## impl<T> OrderedContainer<T> for T

where T: Clone,

### Description
Provides blanket implementation for the `OrderedContainer` trait.
```

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

### Implement Error for Error (provide method - Nightly Experimental)

Source: https://docs.rs/knuffel/3.2.0/knuffel/errors/struct.Error.html

Nightly-only experimental API for providing type-based access to context for error reports.

```rust
fn provide<'a>(&'a self, request: &mut Request<'a>)
```

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

### Get Substring Range

Source: https://docs.rs/knuffel/3.2.0/knuffel/ast/struct.TypeName.html

Finds the range of a substring within the original string using pointer arithmetic. Requires the `substr_range` feature.

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

let data = "a, b, b, a";
let mut iter = data.split(", ").map(|s| data.substr_range(s).unwrap());

assert_eq!(iter.next(), Some(0..1));
assert_eq!(iter.next(), Some(3..4));
assert_eq!(iter.next(), Some(6..7));
assert_eq!(iter.next(), Some(9..10));
```

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

### pub fn find<P>(&self, pat: P) -> Option<usize>

Source: https://docs.rs/knuffel/3.2.0/knuffel/ast/struct.TypeName.html

Returns the byte index of the first character of this string slice that matches the pattern.

```APIDOC
## find

### Description
Returns the byte index of the first character of this string slice that matches the pattern. Returns None if the pattern doesn't match.

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

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

### Iterate Over Bytes in a String

Source: https://docs.rs/knuffel/3.2.0/knuffel/ast/struct.TypeName.html

Use `bytes()` to get an iterator over the individual bytes of a string slice. This is useful for low-level byte manipulation.

```Rust
let mut bytes = "bors".bytes();

assert_eq!(Some(b'b'), bytes.next());
assert_eq!(Some(b'o'), bytes.next());
assert_eq!(Some(b'r'), bytes.next());
assert_eq!(Some(b's'), bytes.next());

assert_eq!(None, bytes.next());
```

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

### Implement Clone for Decimal

Source: https://docs.rs/knuffel/3.2.0/knuffel/ast/struct.Decimal.html

Provides methods for cloning Decimal values. `clone` creates a duplicate, while `clone_from` performs copy-assignment.

```rust
fn clone(&self) -> Decimal
```

```rust
fn clone_from(&mut self, source: &Self)
```

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

### Type Conversions (From/Into)

Source: https://docs.rs/knuffel/3.2.0/knuffel/ast/struct.Integer.html

Provides methods for converting between types using `From` and `Into` traits.

```APIDOC
## POST /websites/rs_knuffel_3_2_0_knuffel/from

### Description
Returns the argument unchanged. This is part of the `From<T> for T` trait implementation.

### Method
POST

### Endpoint
/websites/rs_knuffel_3_2_0_knuffel/from

### Parameters
#### Request Body
- **t** (T) - Required - The value to convert.

### Request Example
```json
{
  "t": "some_value"
}
```

### Response
#### Success Response (200)
- **T** (T) - The original value, unchanged.
```

```APIDOC
## POST /websites/rs_knuffel_3_2_0_knuffel/into

### Description
Calls `U::from(self)`. This conversion is determined by the implementation of `From<T> for U`.

### Method
POST

### Endpoint
/websites/rs_knuffel_3_2_0_knuffel/into

### Parameters
#### Request Body
- **self** (T) - Required - The value to convert.

### Request Example
```json
{
  "self": "some_value"
}
```

### Response
#### Success Response (200)
- **U** (U) - The converted value.
```

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

### Get String Representation of TypeName

Source: https://docs.rs/knuffel/3.2.0/knuffel/ast/struct.TypeName.html

Returns the string representation of the type name. This method is part of the TypeName struct's implementation.

```rust
pub fn as_str(&self) -> &str
```

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

### Unsafely Get Subslice of String

Source: https://docs.rs/knuffel/3.2.0/knuffel/ast/struct.TypeName.html

Returns an unchecked subslice of the string slice. This method bypasses bounds checks and should be used with extreme caution.

```rust
pub unsafe fn get_unchecked<I>(&self, i: I) -> &<I as SliceIndex<str>>::Output>
where I: SliceIndex<str>,
```

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

### Node Implementations

Source: https://docs.rs/knuffel/3.2.0/knuffel/ast/struct.Node.html

Provides details on the methods and trait implementations available for the Node struct.

```APIDOC
## impl<S> Node<S>

### children
Returns node children

### impl<S: Clone> Clone for Node<S>

### clone
Returns a duplicate of the value.

### clone_from
Performs copy-assignment from `source`.

### impl<S: Debug> Debug for Node<S>

### fmt
Formats the value using the given formatter.

### impl<S, T> Decode<S> for Node<T>

### decode_node
Decodes the node from the ast
```

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

### trim_start_matches

Source: https://docs.rs/knuffel/3.2.0/knuffel/ast/struct.TypeName.html

Removes all leading prefixes that match a specified pattern.

```APIDOC
## trim_start_matches

### Description
Returns a string slice with all prefixes that match a pattern repeatedly removed.

### Parameters
- **pat** (Pattern) - Required - The pattern to match (can be &str, char, slice of chars, or closure).

### Request Example
"11foo1bar11".trim_start_matches('1')

### Response
- **Result** (str) - The resulting string slice.
```

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

### Get Node Children in Rust

Source: https://docs.rs/knuffel/3.2.0/knuffel/ast/struct.Node.html

Returns an iterator over the node's children. This method is useful for traversing the tree structure of a KDL document.

```rust
pub fn children( &self, ) -> impl Iterator<Item = &Spanned<Node<S>, S>> + ExactSizeIterator
```

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

### Trim leading whitespace

Source: https://docs.rs/knuffel/3.2.0/knuffel/ast/struct.TypeName.html

Removes leading whitespace from a string slice. Note that 'start' refers to the beginning of the byte sequence, which varies by text directionality.

```rust
let s = "\n Hello\tworld\t\n";
assert_eq!("Hello\tworld\t\n", s.trim_start());
```

```rust
let s = "  English  ";
assert!(Some('E') == s.trim_start().chars().next());

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

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

### Split string with a closure pattern

Source: https://docs.rs/knuffel/3.2.0/knuffel/ast/struct.TypeName.html

Demonstrates using `rsplitn` with a closure as a pattern to split the string based on multiple delimiter conditions.

```rust
let v: Vec<&str> = "abc1defXghi".rsplitn(2, |c| c == '1' || c == 'X').collect();
assert_eq!(v, ["ghi", "abc1def"]);
```

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

### Implement Diagnostic for Error (source_code method)

Source: https://docs.rs/knuffel/3.2.0/knuffel/errors/struct.Error.html

Returns the source code to which the diagnostic labels should be applied.

```rust
fn source_code(&self) -> Option<&dyn SourceCode>
```

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

### Find all occurrences of a pattern

Source: https://docs.rs/knuffel/3.2.0/knuffel/ast/struct.TypeName.html

Use `matches` to get an iterator over all disjoint occurrences of a pattern within a string. The pattern can be a string slice, char, or a closure.

```rust
let v: Vec<&str> = "abcXXXabcYYYabc".matches("abc").collect();
assert_eq!(v, ["abc", "abc", "abc"]);
```

```rust
let v: Vec<&str> = "1abc2abc3".matches(char::is_numeric).collect();
assert_eq!(v, ["1", "2", "3"]);
```

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

### Trait Implementations for Integer

Source: https://docs.rs/knuffel/3.2.0/knuffel/ast/struct.Integer.html

Details various trait implementations for the Integer type, including Clone, Debug, PartialEq, and TryFrom conversions.

```APIDOC
### impl Clone for Integer

- `fn clone(&self) -> Integer`
- `fn clone_from(&mut self, source: &Self)`

### impl Debug for Integer

- `fn fmt(&self, f: &mut Formatter<'_>) -> Result`

### impl PartialEq for Integer

- `fn eq(&self, other: &Integer) -> bool`
- `fn ne(&self, other: &Rhs) -> bool`

### impl TryFrom<&Integer> for i16

- `type Error = <i16 as FromStr>::Err`
- `fn try_from(val: &Integer) -> Result<i16, <i16 as FromStr>::Err>`

### impl TryFrom<&Integer> for i32

- `type Error = <i32 as FromStr>::Err`
- `fn try_from(val: &Integer) -> Result<i32, <i32 as FromStr>::Err>`

### impl TryFrom<&Integer> for i64

- `type Error = <i64 as FromStr>::Err`
- `fn try_from(val: &Integer) -> Result<i64, <i64 as FromStr>::Err>`

### impl TryFrom<&Integer> for i8

- `type Error = <i8 as FromStr>::Err`
- `fn try_from(val: &Integer) -> Result<i8, <i8 as FromStr>::Err>`

### impl TryFrom<&Integer> for isize

- `type Error = <isize as FromStr>::Err`
- `fn try_from(val: &Integer) -> Result<isize, <isize as FromStr>::Err>`

### impl TryFrom<&Integer> for u16

- `type Error = <u16 as FromStr>::Err`
- `fn try_from(val: &Integer) -> Result<u16, <u16 as FromStr>::Err>`

### impl TryFrom<&Integer> for u32

- `type Error = <u32 as FromStr>::Err`
- `fn try_from(val: &Integer) -> Result<u32, <u32 as FromStr>::Err>`

### impl TryFrom<&Integer> for u64

- `type Error = <u64 as FromStr>::Err`
- `fn try_from(val: &Integer) -> Result<u64, <u64 as FromStr>::Err>`

### impl TryFrom<&Integer> for u8

- `type Error = <u8 as FromStr>::Err`
- `fn try_from(val: &Integer) -> Result<u8, <u8 as FromStr>::Err>`

### impl TryFrom<&Integer> for usize

- `type Error = <usize as FromStr>::Err`
- `fn try_from(val: &Integer) -> Result<usize, <usize as FromStr>::Err>`

### impl Eq for Integer

### impl StructuralPartialEq for Integer
```

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

### Blanket Implementations for Document

Source: https://docs.rs/knuffel/3.2.0/knuffel/ast/struct.Document.html

Details blanket implementations available for the Document struct, providing generic functionality.

```APIDOC
## Blanket Implementations

### impl<T> Any for T
where T: 'static + ?Sized,

#### fn type_id(&self) -> TypeId
Gets the `TypeId` of `self`.

### impl<T> Borrow<T> for T
where T: ?Sized,

#### fn borrow(&self) -> &T
Immutably borrows from an owned value.

### impl<T> BorrowMut<T> for T
where T: ?Sized,

#### fn borrow_mut(&mut self) -> &mut T
Mutably borrows from an owned value.

### impl<T> Chain<T> for T

#### fn len(&self) -> usize
The number of items that this chain link consists of.

#### fn append_to(self, v: &mut Vec<T>)
Append the elements in this link to the chain.

### impl<T> CloneToUninit for T
where T: Clone,

#### unsafe fn clone_to_uninit(&self, dest: *mut u8)
Performs copy-assignment from `self` to `dest`.

### impl<T> Container<T> for T
where T: Clone,

#### type Iter = Once<T>
An iterator over the items within this container, by value.

#### fn get_iter(&self) -> <T as Container<T>>::Iter
Iterate over the elements of the container.

### impl<T> From<T> for T

#### fn from(t: T) -> T
Returns the argument unchanged.

### impl<T, U> Into<U> for T
where U: From<T>,

#### fn into(self) -> U
Calls `U::from(self)`.

### impl<T> ToOwned for T
where T: Clone,

#### type Owned = T
The resulting type after obtaining ownership.

#### fn to_owned(&self) -> T
Creates owned data from borrowed data, usually by cloning.

#### fn clone_into(&self, target: &mut T)
Uses borrowed data to replace owned data, usually by cloning.

### impl<T, U> TryFrom<U> for T
where U: Into<T>,

#### type Error = Infallible
The type returned in the event of a conversion error.

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

### impl<T, U> TryInto<U> for T
where U: TryFrom<T>,

#### type Error = <U as TryFrom<T>>::Error
The type returned in the event of a conversion error.

#### fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>
Performs the conversion.

### impl<T> OrderedContainer<T> for T
where T: Clone
```

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

### Iterate Over Character Indices in a String

Source: https://docs.rs/knuffel/3.2.0/knuffel/ast/struct.TypeName.html

Use `char_indices()` to get an iterator over the byte index and character of a string. This is useful for understanding character boundaries and multi-byte characters.

```Rust
let word = "goodbye";

let count = word.char_indices().count();
assert_eq!(7, count);

let mut char_indices = word.char_indices();

assert_eq!(Some((0, 'g')), char_indices.next());
assert_eq!(Some((1, 'o')), char_indices.next());
assert_eq!(Some((2, 'o')), char_indices.next());
assert_eq!(Some((3, 'd')), char_indices.next());
assert_eq!(Some((4, 'b')), char_indices.next());
assert_eq!(Some((5, 'y')), char_indices.next());
assert_eq!(Some((6, 'e')), char_indices.next());

assert_eq!(None, char_indices.next());
```

```Rust
let yes = "y̆es";

let mut char_indices = yes.char_indices();

assert_eq!(Some((0, 'y')), char_indices.next()); // not (0, 'y̆')
assert_eq!(Some((1, '\u{0306}')), char_indices.next());

// note the 3 here - the previous character took up two bytes
assert_eq!(Some((3, 'e')), char_indices.next());
assert_eq!(Some((4, 's')), char_indices.next());

assert_eq!(None, char_indices.next());
```

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

### Safely Get Subslice of String

Source: https://docs.rs/knuffel/3.2.0/knuffel/ast/struct.TypeName.html

Returns a subslice of the string slice. This is a non-panicking alternative to direct indexing, returning `None` if the requested slice is invalid or out of bounds.

```rust
let v = String::from("🗻∈🌏");

assert_eq!(Some("🗻"), v.get(0..4));

// indices not on UTF-8 sequence boundaries
assert!(v.get(1..).is_none());
assert!(v.get(..8).is_none());

// out of bounds
assert!(v.get(..42).is_none());
```

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

### Repeat String

Source: https://docs.rs/knuffel/3.2.0/knuffel/ast/struct.TypeName.html

Explains the `repeat` method for creating a new string by repeating the original string `n` times.

```APIDOC
## Repeat String

### Description
Creates a new `String` by repeating a string `n` times.

### Method
`repeat`

### Parameters
- `n` (usize): The number of times to repeat the string.

### Panics
This function will panic if the capacity would overflow.

### Request Example
```rust
assert_eq!("abc".repeat(4), String::from("abcabcabcabc"));
```

### Response
A new `String` consisting of the original string repeated `n` times.
```

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

### Split string into at most N pieces

Source: https://docs.rs/knuffel/3.2.0/knuffel/ast/struct.TypeName.html

Use `rsplitn` to split a string into a specified maximum number of pieces, starting from the right. The last piece will contain the remainder of the string.

```rust
let v: Vec<&str> = "Mary had a little lamb".rsplitn(3, ' ').collect();
assert_eq!(v, ["lamb", "little", "Mary had a"]);
```

```rust
let v: Vec<&str> = "lionXXtigerXleopard".rsplitn(3, 'X').collect();
assert_eq!(v, ["leopard", "tiger", "lionX"]);
```

```rust
let v: Vec<&str> = "lion::tiger::leopard".rsplitn(2, "::").collect();
assert_eq!(v, ["leopard", "lion::tiger"]);
```

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

### Get Length of String Slice

Source: https://docs.rs/knuffel/3.2.0/knuffel/ast/struct.TypeName.html

Returns the length of the string slice in bytes. Note that this may not correspond to the human-perceived character count, especially with multi-byte UTF-8 characters.

```rust
let len = "foo".len();
assert_eq!(3, len);

assert_eq!("ƒoo".len(), 4); // fancy f!
assert_eq!("ƒoo".chars().count(), 3);
```

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

### Derive Macros for KDL Parsing

Source: https://docs.rs/knuffel

Demonstrates using `knuffel::Decode` derive macro to parse KDL into Rust enums and structs.

```rust
#[derive(knuffel::Decode)]
enum TopLevelNode {
    Route(Route),
    Plugin(Plugin),
}

#[derive(knuffel::Decode)]
struct Route {
    #[knuffel(argument)]
    path: String,
    #[knuffel(children(name="route"))]
    subroutes: Vec<Route>,
}

#[derive(knuffel::Decode)]
struct Plugin {
    #[knuffel(argument)]
    name: String,
    #[knuffel(property)]
    url: String,
}

let config = knuffel::parse::<Vec<TopLevelNode>>("example.kdl", r#"    route "/api" {
        route "/api/v1"
    }
    plugin "http" url="https://example.org/http"
"#)?;
```

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

### Get Iterator for BuiltinType Container

Source: https://docs.rs/knuffel/3.2.0/knuffel/ast/enum.BuiltinType.html

Implements the `get_iter` method for the `Container` trait for BuiltinType. This method returns an iterator over the elements within the container, using internal iteration.

```rust
type Iter = Once<T>;
fn get_iter(&self) -> <T as Container<T>>::Iter
```

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

### Type Conversions (TryFrom/TryInto)

Source: https://docs.rs/knuffel/3.2.0/knuffel/ast/struct.Integer.html

Provides methods for fallible type conversions using `TryFrom` and `TryInto` traits.

```APIDOC
## POST /websites/rs_knuffel_3_2_0_knuffel/try_from

### Description
Performs a fallible conversion from type U to type T.

### Method
POST

### Endpoint
/websites/rs_knuffel_3_2_0_knuffel/try_from

### Parameters
#### Request Body
- **value** (U) - Required - The value to convert.

### Request Example
```json
{
  "value": "some_value"
}
```

### Response
#### Success Response (200)
- **Result<T, Error>** - Ok(T) on success, Err(Error) on failure.

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

```APIDOC
## POST /websites/rs_knuffel_3_2_0_knuffel/try_into

### Description
Performs a fallible conversion from type T to type U.

### Method
POST

### Endpoint
/websites/rs_knuffel_3_2_0_knuffel/try_into

### Parameters
#### Request Body
- **self** (T) - Required - The value to convert.

### Request Example
```json
{
  "self": "some_value"
}
```

### Response
#### Success Response (200)
- **Result<U, Error>** - Ok(U) on success, Err(Error) on failure.

#### Error Response
- **Error** (<U as TryFrom<T>>::Error) - The type returned in the event of a conversion error.
```

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

### rmatch_indices() - Reverse Match Indices

Source: https://docs.rs/knuffel/3.2.0/knuffel/ast/struct.TypeName.html

Finds all non-overlapping matches of a pattern in a string and returns an iterator over the starting indices and the matched string slices. The search is performed from right to left.

```APIDOC
## rmatch_indices<P>(pat: P)

### Description
Finds all non-overlapping matches of a pattern in a string and returns an iterator over the starting indices and the matched string slices. The search is performed from right to left.

### Method
`&self` (implicitly a method on string slices)

### Endpoint
N/A (String method)

### Parameters
#### Path Parameters
N/A

#### Query Parameters
N/A

#### Request Body
- **pat** (P: Pattern) - Required - The pattern to search for.

### Response
#### Success Response (200)
- **Iterator** - An iterator yielding tuples of (index, matched_slice).

### Request Example
```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`
```

### Response Example
```json
{
  "example": "[(index, matched_slice), ...]"
}
```
```

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

### Clone Implementation for Document

Source: https://docs.rs/knuffel/3.2.0/knuffel/ast/struct.Document.html

Provides methods for cloning a Document instance.

```APIDOC
### impl<S: Clone> Clone for Document<S>

#### fn clone(&self) -> Document<S>
Returns a duplicate of the value.

#### fn clone_from(&mut self, source: &Self)
Performs copy-assignment from `source`.
```
Tokens:
Raw