currency_engineering/keytree - Change UIKYQQM27ZMSXVMJ6U6XLEKLDUGFMCUKWLS6Z5DBMKDNJN4PDN6QC

Improved error handling.

Created by CrEcTsRjb1hHQjHuumqRfqdbVV4X58iLEubi4noaDPFa on August 1, 2021

UIKYQQM27ZMSXVMJ6U6XLEKLDUGFMCUKWLS6Z5DBMKDNJN4PDN6QC

Dependencies

In channels

main

Change contents

Replacement in src/parser.rs at line 5 [6.2239]

∅:D[4.45] → [5.0:278]

B:BD[6.2330] → [5.0:278]

use crate::error::Error;
use crate::error::{
    bad_indent,
    colon_before_key,
    empty_string,
    first_token_must_be_key,
    incomplete_comment_or_key,
    incomplete_line,
    no_colon_after_key,
    no_space_after_key,
    no_tokens,
    non_root_has_zero_indent,
};

[4.45]

[5.278]

use crate::error::*;

Replacement in src/parser.rs at line 33 [6.2239]

B:BD[5.475] → [5.475:528]

        bad_indent(&token.to_string(), line, self.0)

[5.475]

[5.528]

        err(file!(), line!(), &format!("Bad indent of {} at line {}.", self.0, line))

Replacement in src/parser.rs at line 110 [6.2239]

B:BD[6.4577] → [7.0:161]

                Err(first_token_must_be_key(
                    file!(),
                    line!(),
                    &token.to_string()
                ))

[6.4577]

[6.4660]

                Err(
                    err(
                        file!(), line!(),
                        &format!("First token {} must be key.", &token),
                    )
                )

Replacement in src/parser.rs at line 157 [6.2239]

B:BD[6.6106] → [5.601:658]

B:BD[5.658] → [7.162:228]

∅:D[7.228] → [5.658:702]

B:BD[5.658] → [5.658:702]

∅:D[5.702] → [6.6219:6256]

B:BD[6.6219] → [6.6219:6256]

B:BD[6.6256] → [8.620:643]

                    return Err(non_root_has_zero_indent(
                        file!(),
                        line!(),
                        &token.to_string(),
                        token.line()
                    ))

[6.6106]

[6.6280]

                    return Err(
                        err(
                            file!(), line!(),
                            &format!("Non-root token {} cannot have zero indent at line {}.",
                                &token,
                                token.line(),
                            ),
                        )
                    )

Replacement in src/parser.rs at line 168 [6.2239]

B:BD[3.1] → [3.1:133]

∅:D[3.133] → [6.6299:6364]

B:BD[6.6299] → [6.6299:6364]

                // TODO: Check indentation. The following line will error if indent suddenly shifts
                // from 1 to 3.
                let parent_ix = self.parents.parent(indent - 1);

[3.1]

[6.6364]

                let parent_ix = match self.parents.parent(indent - 1) {
                    Some(ix) => ix,
                    None => { return Err(
                        err(
                            file!(), line!(),
                            &format!("Unexpected indent at line {}.", token.line()),
                        )
                    )},
                };

Replacement in src/parser.rs at line 221 [6.2239]

B:BD[6.8072] → [8.644:695]

        if s == "" { return Err(empty_string()) };

[6.8072]

[6.8143]

        if s == "" { return Err(err(file!(), line!(), "Empty string.")) };

Replacement in src/parser.rs at line 385 [6.2239]

B:BD[8.797] → [8.797:841]

B:BD[8.841] → [7.291:365]

∅:D[7.365] → [4.123:213]

B:BD[8.841] → [4.123:213]

                        no_colon_after_key(
                            file!(),
                            line!(),
                            &token_str.to_string(),
                            line + 1,

[8.797]

[9.972]

                        err(
                            file!(), line!(),
                            &format!("No colon after key {} at line {}.", &token_str, line + 1),

Replacement in src/parser.rs at line 394 [6.2239]

B:BD[8.898] → [5.880:931]

B:BD[5.931] → [7.366:440]

∅:D[7.440] → [5.931:1021]

B:BD[5.931] → [5.931:1021]

                        incomplete_comment_or_key(
                            file!(),
                            line!(),
                            &token_str.to_string(),
                            line + 1,

[8.898]

[9.1175]

                        err(
                            file!(), line!(),
                            &format!("Incomplete comment of key {} at {}.", &token_str, line + 1),

Replacement in src/parser.rs at line 406 [6.2239]

B:BD[7.533] → [7.533:752]

                    return Err(no_space_after_key(
                        file!(),
                        line!(),
                        &token_str.to_string(),
                        line,
                    ));

[7.533]

[6.14046]

                    return Err(
                        err(
                            file!(), line!(),
                            &format!("No space after key {} at line {}.", &token_str, line),
                        )
                    );

Replacement in src/parser.rs at line 419 [6.2239]

B:BD[8.1010] → [8.1010:1051]

B:BD[8.1051] → [7.753:827]

∅:D[7.827] → [5.1077:1159]

B:BD[8.1051] → [5.1077:1159]

                        incomplete_line(
                            file!(),
                            line!(),
                            &String::from("/"),
                            line,

[8.1010]

[9.1485]

                        err(
                            file!(), line!(),
                            &format!("Incomplete line {} at {}.", &String::from("/"), line),

Replacement in src/parser.rs at line 429 [6.2239]

B:BD[8.1107] → [8.1107:1148]

B:BD[8.1148] → [7.828:902]

∅:D[7.902] → [5.1160:1246]

B:BD[8.1148] → [5.1160:1246]

                        incomplete_line(
                            file!(),
                            line!(),
                            &token_str.to_string(),
                            line,

[8.1107]

[9.1679]

                        err(
                            file!(), line!(),
                            &format!("Incomplete line {} at {}.", &token_str, line),

Replacement in src/parser.rs at line 441 [6.2239]

B:BD[7.995] → [7.995:1211]

                    return Err(colon_before_key(
                        file!(),
                        line!(),
                        &token_str.to_string(),
                        line,
                    ))

[7.995]

[6.14732]

                    return Err(
                        err(
                            file!(), line!(),
                            &format!("Colon before key {} at {}.", &token_str, line),
                        )
                    )

Replacement in src/parser.rs at line 451 [6.2239]

B:BD[7.1304] → [7.1304:1520]

                    return Err(colon_before_key(
                        file!(),
                        line!(),
                        &token_str.to_string(),
                        line,
                    ))

[7.1304]

[6.14905]

                    return Err(
                        err(
                            file!(), line!(),
                            &format!("Colon before key {} at {}.", &token_str, line),
                        )
                    )

Replacement in src/parser.rs at line 461 [6.2239]

B:BD[7.1613] → [7.1613:1831]

                    return Err(no_space_after_key(
                        file!(),
                        line!(),
                        &token_str.to_string(),
                        line,
                    ))

[7.1613]

[6.15040]

                    return Err(
                        err(
                            file!(), line!(),
                            &format!("No space after key {} at {}.", &token_str, line),
                        )
                    )

Replacement in src/parser.rs at line 474 [6.2239]

B:BD[7.1924] → [7.1924:2142]

                    return Err(no_space_after_key(
                        file!(),
                        line!(),
                        &token_str.to_string(),
                        line,
                    ))

[7.1924]

[6.15457]

                    return Err(
                        err(
                            file!(), line!(),
                            &format!("No space after key {} at line {}.", &token_str, line),
                        )
                    )

Replacement in src/parser.rs at line 493 [6.2239]

B:BD[8.1411] → [8.1411:1458]

B:BD[8.1458] → [7.2143:2209]

∅:D[7.2209] → [5.1301:1379]

B:BD[8.1458] → [5.1301:1379]

                    incomplete_comment_or_key(
                        file!(),
                        line!(),
                        &token_str.to_string(),
                        line,

[8.1411]

[9.2548]

                    err(
                        file!(), line!(),
                        &format!("Incomplete comment or key {} at line {}.", &token_str, line),

Replacement in src/parser.rs at line 503 [6.2239]

B:BD[8.1506] → [8.1506:1543]

B:BD[8.1543] → [7.2210:2276]

∅:D[7.2276] → [5.1380:1458]

B:BD[8.1543] → [5.1380:1458]

                    incomplete_line(
                        file!(),
                        line!(),
                        &token_str.to_string(),
                        line,

[8.1506]

[9.2723]

                    err(
                        file!(), line!(),
                        &format!("Incomplete line {} at {}.", &token_str, line)

Replacement in src/parser.rs at line 558 [6.2239]

B:BD[6.17635] → [7.2277:2369]

            Err(no_tokens(
                file!(),
                line!(),
            ))

[6.17635]

[6.17684]

            Err(err(file!(), line!(), "No tokens"))

Replacement in src/lib.rs at line 435 [6.18441]

B:BD[4.3514] → [4.3514:3632]

                Err(expected_keyvalue_found_key(
                    &format!("{}:", key),
                    *line,

[4.3514]

[4.3632]

                Err(err(
                    file!(), line!(),
                    &format!("Expected keyvalue found key {} at {}.",
                        key,
                        line,
                    )

Replacement in src/lib.rs at line 450 [6.18441]

B:BD[4.4148] → [4.4148:4308]

            Err(first_segment_mismatch(
                &self.top_token().to_string(),
                self.top_token().line(),
                parent_segment,

[4.4148]

[4.4308]

            Err(err(file!(), line!(),
                &format!("First segment mismatch {} {} at {}.",
                    &self.top_token(),
                    parent_segment,
                    self.top_token().line(),
                )

Replacement in src/lib.rs at line 477 [6.18441]

B:BD[4.4509] → [3.477:556]

            .map_err(|_| parse_value_failed(&token.to_string(), token.line()))

[4.4509]

[4.4591]

            .map_err(|_| err(file!(), line!(),
                &format!("Failed to parse {} at {}.",
                    token,
                    token.line(),
                )
            ))

Replacement in src/lib.rs at line 496 [6.18441]

B:BD[4.4819] → [7.2426:2514]

            _ => Err(expected_unique_keyvalue_found_multi(file!(), line!(), key_path)),

[4.4819]

[6.23294]

            _ => Err(err(
                file!(),
                line!(),
                &format!("Expected unique keyvalue found multi at {}.", key_path),
            )),

Replacement in src/lib.rs at line 513 [6.18441]

B:BD[4.5165] → [7.2515:2602]

            0 => Err(expected_unique_keyvalue_found_none(file!(), line!(), key_path)),

[4.5165]

[4.5234]

            0 => Err(err(
                file!(),
                line!(),
                &format!("Expected unique keyvalue found none at {}.", key_path),
            )),

Replacement in src/lib.rs at line 519 [6.18441]

B:BD[4.5275] → [7.2603:2691]

            _ => Err(expected_unique_keyvalue_found_multi(file!(), line!(), key_path)),

[4.5275]

[4.5345]

            _ => Err(err(
                file!(),
                line!(),
                &format!("Expected unique keyvalue found multi at {}.", key_path),
            )),

Replacement in src/lib.rs at line 572 [6.18441]

B:BD[4.5574] → [7.2692:2779]

            0 => Err(expected_unique_keyvalue_found_none(file!(), line!(), key_path)),

[4.5574]

[4.5643]

            0 => Err(err(
                file!(),
                line!(),
                &format!("Expected unique keyvalue found none at {}.", key_path),
            )),

Replacement in src/lib.rs at line 578 [6.18441]

B:BD[4.5689] → [7.2780:2868]

            _ => Err(expected_unique_keyvalue_found_multi(file!(), line!(), key_path)),

[4.5689]

[4.5759]

            _ => Err(err(
                file!(),
                line!(),
                &format!("Expected unique keyvalue found multi at {}.", key_path),
            )),

Replacement in src/lib.rs at line 597 [6.18441]

B:BD[4.6069] → [7.2869:2957]

            _ => Err(expected_unique_keyvalue_found_multi(file!(), line!(), key_path)),

[4.6069]

[4.6139]

            _ => Err(err(
                file!(),
                line!(),
                &format!("Expected unique keyvalue found multi at {}.", key_path),
            )),

Replacement in src/lib.rs at line 619 [6.18441]

B:BD[10.1872] → [10.1872:2016]

            return Err(expected_non_empty_collection(
                file!(),
                line!(),
                key_path
            ))

[10.1872]

[10.2016]

            return Err(
                err(file!(), line!(), &format!("Expected non-empty collection at {}.", key_path))
            )

Replacement in src/lib.rs at line 656 [6.18441]

B:BD[7.3290] → [7.3290:3434]

            return Err(expected_non_empty_collection(
                file!(),
                line!(),
                key_path
            ))

[7.3290]

[7.3434]

            return Err(
                err(file!(), line!(), &format!("Expected non-empty collection at {}.", key_path))
            )

Replacement in src/lib.rs at line 747 [6.18441]

∅:D[2.213] → [4.9272:9454]

B:BD[4.9272] → [4.9272:9454]

                return Err(keypath_extends_beyond_keyvalue(
                    &format!("{}: {}", key, value),
                    *line,
                    &key_path.to_string(),

[2.213]

[4.9454]

                return Err(err(file!(), line!(),
                    &format!("Line {} keypath {}. Keypath_extends_beyond_keyvalue {}: {}.",
                        *line,
                        &key_path,
                        key,
                        value,
                    )

Deletion in src/error.rs at line 1 [6.36577]
B:BD[6.36577] → [5.6272:6329]
∅:D[5.6329] → [6.36664:36665]
B:BD[6.36664] → [6.36664:36665]
B:BD[6.36665] → [5.6330:6368]
```
// `Token` is passed as a string to 'cut' the reference.
// use std::error::Error as StdError;
```
Deletion in src/error.rs at line 5 [6.36577]
∅:D[8.2067] → [11.664:665]
B:BD[6.36956] → [11.664:665]
B:BD[11.665] → [5.6383:6407]
```
// TODO: impl StdError;
```

Deletion in src/error.rs at line 10 [6.36577]

B:BD[6.37428] → [6.37428:37431]

B:BD[6.37431] → [4.9507:9603]

B:BD[4.9603] → [3.557:623]

∅:D[3.623] → [4.9664:9717]

∅:D[7.3602] → [4.9664:9717]

B:BD[4.9664] → [4.9664:9717]

∅:D[8.2314] → [6.38892:38895]

∅:D[4.9717] → [6.38892:38895]

B:BD[6.38892] → [6.38892:38895]

B:BD[6.38895] → [4.9718:9807]

B:BD[4.9807] → [3.624:698]

∅:D[3.698] → [4.9876:9928]

∅:D[7.3680] → [4.9876:9928]

B:BD[4.9876] → [4.9876:9928]

∅:D[8.2435] → [6.39071:39074]

∅:D[4.9928] → [6.39071:39074]

B:BD[6.39071] → [6.39071:39074]

B:BD[6.39074] → [4.9929:10027]

B:BD[4.10027] → [3.699:777]

∅:D[3.777] → [4.10100:10136]

∅:D[7.3762] → [4.10100:10136]

B:BD[4.10100] → [4.10100:10136]

∅:D[8.2689] → [6.40365:40368]

∅:D[4.10136] → [6.40365:40368]

B:BD[6.40365] → [6.40365:40368]

B:BD[6.40368] → [7.3763:3871]

B:BD[7.3871] → [3.778:844]

∅:D[3.844] → [7.3940:4009]

B:BD[7.3940] → [7.3940:4009]

∅:D[7.4009] → [8.2834:2836]

∅:D[4.10224] → [8.2834:2836]

B:BD[8.2834] → [8.2834:2836]

∅:D[8.2836] → [6.43075:43076]

B:BD[6.43075] → [6.43075:43076]

B:BD[6.43076] → [4.10225:10256]

B:BD[4.10256] → [7.4010:4062]

∅:D[7.4062] → [4.10300:10336]

B:BD[4.10300] → [4.10300:10336]

B:BD[4.10336] → [7.4063:4128]

∅:D[7.4128] → [8.3058:3060]

∅:D[4.10393] → [8.3058:3060]

B:BD[8.3058] → [8.3058:3060]

∅:D[8.3060] → [6.43212:43213]

B:BD[6.43212] → [6.43212:43213]

B:BD[6.43213] → [4.10394:10485]

B:BD[4.10485] → [3.845:927]

∅:D[3.927] → [4.10562:10692]

∅:D[7.4214] → [4.10562:10692]

B:BD[4.10562] → [4.10562:10692]

B:BD[4.10692] → [3.928:1010]

∅:D[3.1010] → [4.10769:10808]

∅:D[7.4300] → [4.10769:10808]

B:BD[4.10769] → [4.10769:10808]

B:BD[4.10808] → [7.4301:4416]

B:BD[7.4416] → [3.1011:1077]

∅:D[3.1077] → [7.4485:4550]

B:BD[7.4485] → [7.4485:4550]

∅:D[7.4550] → [4.10808:10889]

B:BD[4.10808] → [4.10808:10889]

B:BD[4.10889] → [3.1078:1163]

∅:D[3.1163] → [4.10969:10994]

∅:D[7.4639] → [4.10969:10994]

B:BD[4.10969] → [4.10969:10994]

∅:D[4.10994] → [8.3191:3193]

B:BD[8.3191] → [8.3191:3193]

∅:D[8.3193] → [6.43461:43462]

B:BD[6.43461] → [6.43461:43462]

B:BD[6.43462] → [7.4640:4739]

∅:D[7.4739] → [4.11066:11085]

B:BD[4.11066] → [4.11066:11085]

B:BD[4.11085] → [3.1164:1262]

∅:D[3.1262] → [7.4841:4874]

B:BD[7.4841] → [7.4841:4874]

∅:D[7.4874] → [4.11172:11197]

B:BD[4.11172] → [4.11172:11197]

}
pub fn bad_first_segment(token: &str, line: usize, segment: &str) -> Error {
    Error(format!(
        "[keytree] line {}, token [{}]. Bad first segment [{}].",
        line,
        token,
        segment,
    ))
}
pub fn bad_indent(token: &str, line: usize, indent: usize) -> Error {
    Error(format!(
        "[keytree] line {}, token [{}]. Indentation of {} is incorrect.",
        line,
        token,
        indent,
    ))
}
pub fn cannot_resolve_token_with_siblings(token: &str, line: usize) -> Error {
    Error(format!(
        "[keytree] line {}, token [{}]. Cannot resolve token with siblings.",
        line,
        token,
    ))
}
pub fn colon_before_key(file: &str, code_line: u32, token: &str, line: usize) -> Error {
    Error(format!(
        "[keytree:{}:{}] Line {}, token [{}]. Colon before key.",
        file,
        code_line,
        line,
        token,
    ))
}
pub fn empty_path() -> Error {
    Error(String::from("[keytree:05] Empty path."))
}
pub fn empty_string() -> Error {
    Error(String::from("[keytree:06] Keytree string is empty."))
}
pub fn expected_key_found_keyvalue(token: &str, line: usize) -> Error {
    Error(format!(
        "[keytree] line {}, token [{}]. Expected [key:] but found [key: value].",
        line,
        token,
    ))
}
pub fn expected_keyvalue_found_key(token: &str, line: usize) -> Error {
    Error(format!(
        "[keytree] line {}, token [{}]. Expected [key: value] but found [key:].",
        line,
        token,
    ))
}
pub fn expected_non_empty_collection(code_file: &str, code_line: u32, keypath: &str) -> Error {
    Error(format!(
        "[keytree:{}:{}] Expected non-empty collection at [{}].",
        code_file,
        code_line,
        keypath,
    ))
}
pub fn expected_unique_found_multi(key_path: &str) -> Error {
    Error(format!(
        "[keytree] keypath: [{}]. Expected unique token but found multiple tokens.",
        key_path,
    ))
}
pub fn expected_unique_keyvalue_found_multi(file: &str, code_line: u32, key_path: &str) -> Error {
    Error(format!(
        "[keytree:{}:{}] keypath: [{}]. Expected unique [key: value] but found multiple tokens.",
        file,
        code_line,
        key_path,
    ))

Replacement in src/error.rs at line 12 [6.36577]

B:BD[6.43585] → [7.4875:4973]

pub fn expected_unique_keyvalue_found_none(file: &str, code_line: u32, key_path: &str) -> Error {

[6.43585]

[4.11268]

pub fn err(code_file: &str, code_line: u32, msg: &str) -> Error {

Replacement in src/error.rs at line 14 [6.36577]

B:BD[4.11287] → [3.1263:1349]

∅:D[3.1349] → [7.5063:5096]

B:BD[7.5063] → [7.5063:5096]

∅:D[7.5096] → [4.11363:11391]

B:BD[4.11363] → [4.11363:11391]

B:BD[4.11391] → [7.5097:5212]

B:BD[7.5212] → [3.1350:1435]

∅:D[3.1435] → [7.5300:5358]

B:BD[7.5300] → [7.5300:5358]

∅:D[7.5358] → [8.3515:3517]

B:BD[8.3515] → [8.3515:3517]

∅:D[8.3517] → [6.43698:43699]

B:BD[6.43698] → [6.43698:43699]

B:BD[6.43699] → [3.1436:1520]

∅:D[3.1520] → [4.11586:11605]

B:BD[4.11586] → [4.11586:11605]

B:BD[4.11605] → [3.1521:1569]

        "[keytree:{}:{}] Keypath [{}]. Expected unique [key: value] but found none.",
        file,
        code_line,
        key_path,
    ))
}
pub fn expected_unique_token_found_multi(file: &str, code_line: u32, key_path: &str) -> Error {
    Error(format!(
        "[keytree:{}:{}] Keypath [{}]. Expected a unique token but found multiple.",
        file,
        code_line,
        key_path,
    ))
}
pub fn external(
    code_file: &str,
    code_line: u32,
    msg: &str) -> Error
{
    Error(format!(
        "[keytree:{}:{}] External error [{}].",

[4.11287]

[3.1569]

        "[ui_data:{}:{}] {}",

Deletion in src/error.rs at line 18 [6.36577]
∅:D[3.1620] → [4.11694:11703]
B:BD[4.11694] → [4.11694:11703]
∅:D[4.11703] → [6.43813:43814]
B:BD[6.43813] → [6.43813:43814]
B:BD[6.43814] → [7.5428:5511]
∅:D[7.5511] → [4.11759:11778]
B:BD[4.11759] → [4.11759:11778]
B:BD[4.11778] → [3.1621:1686]
∅:D[3.1686] → [7.5580:5613]
B:BD[7.5580] → [7.5580:5613]
∅:D[7.5613] → [4.11832:11854]
B:BD[4.11832] → [4.11832:11854]
∅:D[8.3600] → [6.43830:43833]
∅:D[4.11854] → [6.43830:43833]
B:BD[6.43830] → [6.43830:43833]
B:BD[6.43833] → [4.11855:11957]
B:BD[4.11957] → [3.1687:1771]
∅:D[3.1771] → [4.12036:12090]
∅:D[7.5701] → [4.12036:12090]
B:BD[4.12036] → [4.12036:12090]
∅:D[5.7012] → [8.3711:3713]
∅:D[4.12090] → [8.3711:3713]
B:BD[8.3711] → [8.3711:3713]
∅:D[8.3713] → [6.43944:43945]
B:BD[6.43944] → [6.43944:43945]
B:BD[6.43945] → [7.5702:5800]
∅:D[7.5800] → [4.12091:12110]
B:BD[5.7083] → [4.12091:12110]
B:BD[4.12110] → [3.1772:1847]
∅:D[3.1847] → [7.5879:5912]
B:BD[7.5879] → [7.5879:5912]
∅:D[7.5912] → [4.12174:12210]
B:BD[4.12174] → [4.12174:12210]
∅:D[4.12210] → [8.3840:3842]
B:BD[8.3840] → [8.3840:3842]
∅:D[8.3842] → [6.43945:43946]
B:BD[6.43945] → [6.43945:43946]
B:BD[6.43946] → [7.5913:6001]
∅:D[7.6001] → [4.12211:12230]
B:BD[5.7144] → [4.12211:12230]
B:BD[4.12230] → [3.1848:1912]
∅:D[3.1912] → [7.6069:6102]
B:BD[7.6069] → [7.6069:6102]
∅:D[7.6102] → [4.12283:12433]
B:BD[4.12283] → [4.12283:12433]
B:BD[4.12433] → [3.1913:2001]
∅:D[3.2001] → [4.12517:12647]
∅:D[7.6194] → [4.12517:12647]
B:BD[4.12517] → [4.12517:12647]
B:BD[4.12647] → [7.6195:6284]
∅:D[7.6284] → [8.3949:3951]
∅:D[4.12728] → [8.3949:3951]
B:BD[8.3949] → [8.3949:3951]
∅:D[8.3951] → [6.44298:44299]
B:BD[6.44298] → [6.44298:44299]
B:BD[6.44299] → [4.12729:12842]
B:BD[4.12842] → [3.2002:2082]
∅:D[3.2082] → [4.12918:12971]
∅:D[7.6368] → [4.12918:12971]
B:BD[4.12918] → [4.12918:12971]
∅:D[5.7242] → [8.4050:4052]
∅:D[4.12971] → [8.4050:4052]
B:BD[8.4050] → [8.4050:4052]
B:BD[8.4052] → [4.12972:13069]
B:BD[4.13069] → [3.2083:2148]
∅:D[3.2148] → [4.13130:13179]
∅:D[7.6437] → [4.13130:13179]
B:BD[4.13130] → [4.13130:13179]
∅:D[5.7385] → [8.4197:4199]
∅:D[4.13179] → [8.4197:4199]
B:BD[6.45016] → [8.4197:4199]
∅:D[8.4199] → [12.350:351]
B:BD[6.45022] → [12.350:351]
B:BD[12.351] → [7.6438:6529]
∅:D[7.6529] → [4.13243:13262]
B:BD[4.13243] → [4.13243:13262]
B:BD[4.13262] → [3.2149:2216]
∅:D[3.2216] → [7.6600:6633]
B:BD[7.6600] → [7.6600:6633]
∅:D[7.6633] → [4.13319:13355]
B:BD[4.13319] → [4.13319:13355]
∅:D[4.13355] → [8.4341:4343]
B:BD[8.4341] → [8.4341:4343]
∅:D[8.4343] → [6.45248:45249]
B:BD[6.45248] → [6.45248:45249]
B:BD[6.45249] → [7.6634:6744]
B:BD[7.6744] → [3.2217:2284]
∅:D[3.2284] → [7.6814:6876]
B:BD[7.6814] → [7.6814:6876]
```
    ))
}
pub fn first_token_must_be_key(file: &str, code_line: u32, token: &str) -> Error {
    Error(format!(
        "[keytree:{}:{}] token {}. First token must be [key:].",
        file,
        code_line,
        token,
    ))
}
pub fn first_segment_mismatch(token: &str, line: usize, key_path: &str) -> Error {
    Error(format!(
        "[keytree] line {}, token [{}]. The first segment of [{}] does not match.",
        line,
        token,
        key_path,
    ))
}
pub fn incomplete_comment_or_key(file: &str, code_line: u32, token: &str, line: usize) -> Error {
    Error(format!(
        "[keytree:{}:{}] line {}, token [{}]. Incomplete comment or key.",
        file,
        code_line,
        line,
        token,
    ))
}
pub fn incomplete_line(file: &str, code_line: u32, token: &str, line: usize) -> Error {
    Error(format!(
       "[keytree:{}:{}] line {}, token [{}]. Incomplete line.",
        file,
        code_line,
        line,
        token,
    ))
}
pub fn keypath_extends_beyond_keyvalue(token: &str, line: usize, key_path: &str) -> Error {
    Error(format!(
        "[keytree] line {} token [{}], keypath [{}]. Keypath extends beyond keyvalue.",
        line,
        token,
        key_path,
    ))
}
pub fn keypath_must_have_two_or_more_segments(key_path: &str) -> Error {
    Error(format!( "[keytree:19] Keypath {} must have two or more segments.", key_path))
}
pub fn keypath_segment_does_not_match_key(token: &str, segment: &str, line: usize) -> Error {
    Error(format!(
        "[keytree] line {} token [{}]. Keypath segment {} does not match key.",
        line,
        token,
        segment,
    ))
}
pub fn no_child_with_segment(token: &str, line: usize, key: &str) -> Error {
    Error(format!(
        "[keytree] line {} token [{}]. Failed to find key [{}]",
        line,
        token,
        key,
    ))
}
pub fn no_colon_after_key(file: &str, code_line: u32, token: &str, line: usize) -> Error {
    Error(format!(
        "[keytree:{}:{}] line {} token [{}], No colon after key.",
        file,
        code_line,
        line,
        token,
    ))
}
pub fn no_space_after_key(file: &str, code_line: u32, token: &str, line: usize) -> Error {
    Error(format!(
        "[keytree:{}:{}] line {} token [{}]. No space after key.",
        file,
        code_line,
        line,
        token,
```
Deletion in src/error.rs at line 20 [6.36577]
∅:D[8.4432] → [6.47289:47290]
B:BD[6.47289] → [6.47289:47290]
B:BD[6.47290] → [7.6884:6959]
B:BD[7.6959] → [3.2285:2341]
∅:D[3.2341] → [7.7018:7058]
B:BD[7.7018] → [7.7018:7058]
∅:D[8.4501] → [6.47727:47730]
∅:D[7.7058] → [6.47727:47730]
∅:D[4.13452] → [6.47727:47730]
B:BD[6.47727] → [6.47727:47730]
B:BD[6.47730] → [7.7059:7156]
∅:D[7.7156] → [4.13522:13541]
B:BD[4.13522] → [4.13522:13541]
B:BD[4.13541] → [3.2342:2434]
∅:D[3.2434] → [7.7252:7286]
B:BD[7.7252] → [7.7252:7286]
B:BD[7.7286] → [3.2435:2623]
∅:D[3.2623] → [4.13622:13658]
∅:D[7.7286] → [4.13622:13658]
B:BD[4.13622] → [4.13622:13658]
∅:D[4.13658] → [8.4572:4574]
B:BD[8.4572] → [8.4572:4574]
B:BD[8.4574] → [3.2624:2625]
```
pub fn no_tokens(file: &str, code_line: u32) -> Error {
    Error(format!(
        "[keytree:{}:{}] No tokens in parsed keytree.",
        file,
        code_line,
    ))
}
pub fn non_root_has_zero_indent(file: &str, code_line: u32, token: &str, line: usize) -> Error {
    Error(format!(
        "[keytree:{}:{}] line {}, token [{}]. Token other than root token as zero indent.",
        file,
        code_line, 
        line,
        token,
    ))
}
pub fn parse_value_failed(token: &str, line: usize) -> Error {
    Error(format!(
        "[keytree] line [{}], token [{}]. Failed to parse value.",
        line,
        token,
    ))
}
```

Replacement in src/builder.rs at line 12 [6.47744]

B:BD[6.47991] → [6.47991:48042]

B:BD[6.48065] → [6.48065:48088]

    pub fn parent(&self, indent: usize) -> usize {
        self.0[indent]

[6.47991]

[6.48088]

    pub fn parent(&self, indent: usize) -> Option<usize> {
        if indent >= self.0.len() {
            None
        } else {
            Some(self.0[indent])
        }

Replacement in examples/hobbit/src/main.rs at line 41 [6.48853]

B:BD[6.49767] → [6.49767:49872]

    let kt = KeyTree::parse(HOBBITS).unwrap();
    let hobbit: Hobbit = kt.to_ref().try_into().unwrap();

[6.49767]

[6.49872]

    let kt = &KeyTree::parse(HOBBITS).unwrap();
    let hobbit: Hobbit = kt.try_into().unwrap();
    &dbg!(&hobbit);
}
fn main() {
    let kt = &KeyTree::parse(HOBBITS).unwrap();
    let hobbit: Hobbit = kt.try_into().unwrap();