Merge branch 'error_rework'

2023-10-17 10:40:46 -04:00 · 2023-10-17 10:40:46 -04:00 · 7d73eb6bd4
commit 7d73eb6bd4
parent acc29e7977 f59f153ee7
36 changed files with 134 additions and 253 deletions
--- a/src/context/context.rs
+++ b/src/context/context.rs
@ -9,7 +9,6 @@ use super::list::List;
 use super::DynContextMatcher;
 use super::RefContext;
 use crate::error::CustomError;
-use crate::error::MyError;
 use crate::error::Res;
 use crate::parser::OrgSource;

@ -108,7 +107,7 @@ impl<'g, 'r, 's> Context<'g, 'r, 's> {
    pub(crate) fn check_exit_matcher(
        &'r self,
        i: OrgSource<'s>,
-    ) -> IResult<OrgSource<'s>, OrgSource<'s>, CustomError<OrgSource<'s>>> {
+    ) -> IResult<OrgSource<'s>, OrgSource<'s>, CustomError> {
        let mut current_class_filter = ExitClass::Gamma;
        for current_node in self.iter_context() {
            let context_element = current_node.get_data();
@ -123,7 +122,7 @@ impl<'g, 'r, 's> Context<'g, 'r, 's> {
            }
        }
        // TODO: Make this a specific error instead of just a generic MyError
-        return Err(nom::Err::Error(CustomError::MyError(MyError("NoExit"))));
+        return Err(nom::Err::Error(CustomError::Static("NoExit")));
    }

    /// Indicates if elements should consume the whitespace after them.
--- a/src/error/error.rs
+++ b/src/error/error.rs
@ -2,22 +2,21 @@ use nom::error::ErrorKind;
 use nom::error::ParseError;
 use nom::IResult;

-pub(crate) type Res<T, U> = IResult<T, U, CustomError<T>>;
+pub(crate) type Res<T, U> = IResult<T, U, CustomError>;

 #[derive(Debug)]
-pub enum CustomError<I> {
-    MyError(MyError<&'static str>),
-    Nom(I, ErrorKind),
+pub enum CustomError {
+    #[allow(dead_code)]
+    Text(String),
+    Static(&'static str),
    IO(std::io::Error),
    BoxedError(Box<dyn std::error::Error>),
+    Parser(ErrorKind),
 }

-#[derive(Debug)]
-pub struct MyError<I>(pub(crate) I);
-
-impl<I> ParseError<I> for CustomError<I> {
-    fn from_error_kind(input: I, kind: ErrorKind) -> Self {
-        CustomError::Nom(input, kind)
+impl<I: std::fmt::Debug> ParseError<I> for CustomError {
+    fn from_error_kind(_input: I, kind: ErrorKind) -> Self {
+        CustomError::Parser(kind)
    }

    fn append(_input: I, _kind: ErrorKind, /*mut*/ other: Self) -> Self {
@ -26,19 +25,19 @@ impl<I> ParseError<I> for CustomError<I> {
    }
 }

-impl<I> From<std::io::Error> for CustomError<I> {
+impl From<std::io::Error> for CustomError {
    fn from(value: std::io::Error) -> Self {
        CustomError::IO(value)
    }
 }

-impl<I> From<&'static str> for CustomError<I> {
+impl From<&'static str> for CustomError {
    fn from(value: &'static str) -> Self {
-        CustomError::MyError(MyError(value))
+        CustomError::Static(value)
    }
 }

-impl<I> From<Box<dyn std::error::Error>> for CustomError<I> {
+impl From<Box<dyn std::error::Error>> for CustomError {
    fn from(value: Box<dyn std::error::Error>) -> Self {
        CustomError::BoxedError(value)
    }
--- a/src/error/mod.rs
+++ b/src/error/mod.rs
@ -1,5 +1,4 @@
 #[allow(clippy::module_inception)]
 mod error;
 pub(crate) use error::CustomError;
-pub(crate) use error::MyError;
 pub(crate) use error::Res;
--- a/src/parser/babel_call.rs
+++ b/src/parser/babel_call.rs
@ -21,7 +21,6 @@ use super::OrgSource;
 use crate::context::Matcher;
 use crate::context::RefContext;
 use crate::error::CustomError;
-use crate::error::MyError;
 use crate::error::Res;
 use crate::parser::util::get_consumed;
 use crate::parser::util::org_line_ending;
@ -217,9 +216,7 @@ fn impl_balanced_bracket<
        }

        if fail_parser(remaining).is_ok() {
-            return Err(nom::Err::Error(CustomError::MyError(MyError(
-                "Fail parser matched.",
-            ))));
+            return Err(nom::Err::Error(CustomError::Static("Fail parser matched.")));
        }

        let (remain, _) = anychar(remaining)?;
--- a/src/parser/citation.rs
+++ b/src/parser/citation.rs
@ -137,7 +137,7 @@ fn _global_prefix_end<'b, 'g, 'r, 's>(
        unreachable!("Exceeded citation global prefix bracket depth.")
    }
    if current_depth == 0 {
-        let close_bracket = tag::<&str, OrgSource<'_>, CustomError<OrgSource<'_>>>("]")(input);
+        let close_bracket = tag::<_, _, CustomError>("]")(input);
        if close_bracket.is_ok() {
            return close_bracket;
        }
@ -191,7 +191,7 @@ fn _global_suffix_end<'b, 'g, 'r, 's>(
        unreachable!("Exceeded citation global suffix bracket depth.")
    }
    if current_depth == 0 {
-        let close_bracket = tag::<&str, OrgSource<'_>, CustomError<OrgSource<'_>>>("]")(input);
+        let close_bracket = tag::<_, _, CustomError>("]")(input);
        if close_bracket.is_ok() {
            return close_bracket;
        }
--- a/src/parser/citation_reference.rs
+++ b/src/parser/citation_reference.rs
@ -20,7 +20,6 @@ use crate::context::ExitClass;
 use crate::context::ExitMatcherNode;
 use crate::context::RefContext;
 use crate::error::CustomError;
-use crate::error::MyError;
 use crate::error::Res;
 use crate::parser::object_parser::minimal_set_object;
 use crate::parser::util::exit_matcher_parser;
@ -151,7 +150,7 @@ fn _key_prefix_end<'b, 'g, 'r, 's>(
        unreachable!("Exceeded citation key prefix bracket depth.")
    }
    if current_depth == 0 {
-        let close_bracket = tag::<&str, OrgSource<'_>, CustomError<OrgSource<'_>>>("]")(input);
+        let close_bracket = tag::<_, _, CustomError>("]")(input);
        if close_bracket.is_ok() {
            return close_bracket;
        }
@ -181,7 +180,7 @@ fn _key_suffix_end<'b, 'g, 'r, 's>(
        unreachable!("Exceeded citation key suffix bracket depth.")
    }
    if current_depth == 0 {
-        let close_bracket = tag::<&str, OrgSource<'_>, CustomError<OrgSource<'_>>>("]")(input);
+        let close_bracket = tag::<_, _, CustomError>("]")(input);
        if close_bracket.is_ok() {
            return close_bracket;
        }
@ -199,9 +198,7 @@ where
        let pre_bracket_depth = input.get_bracket_depth();
        let (remaining, output) = inner(input)?;
        if remaining.get_bracket_depth() - pre_bracket_depth != 0 {
-            return Err(nom::Err::Error(CustomError::MyError(MyError(
-                "UnbalancedBrackets",
-            ))));
+            return Err(nom::Err::Error(CustomError::Static("UnbalancedBrackets")));
        }
        Ok((remaining, output))
    }
--- a/src/parser/comment.rs
+++ b/src/parser/comment.rs
@ -19,7 +19,6 @@ use crate::context::parser_with_context;
 use crate::context::ContextElement;
 use crate::context::RefContext;
 use crate::error::CustomError;
-use crate::error::MyError;
 use crate::error::Res;
 use crate::parser::util::exit_matcher_parser;
 use crate::parser::util::immediate_in_section;
@ -35,9 +34,9 @@ pub(crate) fn comment<'b, 'g, 'r, 's>(
    input: OrgSource<'s>,
 ) -> Res<OrgSource<'s>, Comment<'s>> {
    if immediate_in_section(context, "comment") {
-        return Err(nom::Err::Error(CustomError::MyError(MyError(
+        return Err(nom::Err::Error(CustomError::Static(
            "Cannot nest objects of the same element",
-        ))));
+        )));
    }
    let parser_context = ContextElement::Context("comment");
    let parser_context = context.with_additional_node(&parser_context);
--- a/src/parser/document.rs
+++ b/src/parser/document.rs
@ -19,9 +19,7 @@ use crate::context::GlobalSettings;
 use crate::context::List;
 use crate::context::RefContext;
 use crate::error::CustomError;
-use crate::error::MyError;
 use crate::error::Res;
-use crate::parser::org_source::convert_error;
 use crate::parser::util::blank_line;
 use crate::types::AstNode;
 use crate::types::Document;
@ -103,7 +101,7 @@ pub fn parse_file_with_settings<'g, 's, P: AsRef<Path>>(
 /// This will not prevent additional settings from being learned during parsing, for example when encountering a "#+TODO".
 #[allow(dead_code)]
 fn document<'s>(context: RefContext<'_, '_, '_, 's>, input: &'s str) -> Res<&'s str, Document<'s>> {
-    let (remaining, doc) = document_org_source(context, input.into()).map_err(convert_error)?;
+    let (remaining, doc) = document_org_source(context, input.into())?;
    Ok((Into::<&str>::into(remaining), doc))
 }

@ -127,16 +125,16 @@ fn document_org_source<'b, 'g, 'r, 's>(
                .get_global_settings()
                .file_access
                .read_file(setup_file)
-                .map_err(|err| nom::Err::<CustomError<OrgSource<'_>>>::Failure(err.into()))
+                .map_err(|err| nom::Err::<CustomError>::Failure(err.into()))
        })
        .collect::<Result<Vec<_>, _>>()?;
    for setup_file in setup_files.iter().map(String::as_str) {
        let (_, setup_file_settings) =
            scan_for_in_buffer_settings(setup_file.into()).map_err(|err| {
                eprintln!("{}", err);
-                nom::Err::Error(CustomError::MyError(MyError(
+                nom::Err::Error(CustomError::Static(
                    "TODO: make this take an owned string so I can dump err.to_string() into it.",
-                )))
+                ))
            })?;
        final_settings.extend(setup_file_settings);
    }
@ -144,9 +142,9 @@ fn document_org_source<'b, 'g, 'r, 's>(
    let new_settings = apply_in_buffer_settings(final_settings, context.get_global_settings())
        .map_err(|err| {
            eprintln!("{}", err);
-            nom::Err::Error(CustomError::MyError(MyError(
+            nom::Err::Error(CustomError::Static(
                "TODO: make this take an owned string so I can dump err.to_string() into it.",
-            )))
+            ))
        })?;
    let new_context = context.with_global_settings(&new_settings);
    let context = &new_context;
@ -173,14 +171,14 @@ fn document_org_source<'b, 'g, 'r, 's>(
            let (remaining, mut document) = _document(&parser_context, input)
                .map(|(rem, out)| (Into::<&str>::into(rem), out))?;
            apply_post_parse_in_buffer_settings(&mut document)
-                .map_err(|err| nom::Err::<CustomError<OrgSource<'_>>>::Failure(err.into()))?;
+                .map_err(|err| nom::Err::<CustomError>::Failure(err.into()))?;
            return Ok((remaining.into(), document));
        }
    }

    // Find final in-buffer settings that do not impact parsing
    apply_post_parse_in_buffer_settings(&mut document)
-        .map_err(|err| nom::Err::<CustomError<OrgSource<'_>>>::Failure(err.into()))?;
+        .map_err(|err| nom::Err::<CustomError>::Failure(err.into()))?;

    Ok((remaining.into(), document))
 }
--- a/src/parser/drawer.rs
+++ b/src/parser/drawer.rs
@ -19,7 +19,6 @@ use crate::context::ExitClass;
 use crate::context::ExitMatcherNode;
 use crate::context::RefContext;
 use crate::error::CustomError;
-use crate::error::MyError;
 use crate::error::Res;
 use crate::parser::element_parser::element;
 use crate::parser::util::blank_line;
@ -48,9 +47,9 @@ where
    AK: IntoIterator<Item = Keyword<'s>>,
 {
    if immediate_in_section(context, "drawer") {
-        return Err(nom::Err::Error(CustomError::MyError(MyError(
+        return Err(nom::Err::Error(CustomError::Static(
            "Cannot nest objects of the same element",
-        ))));
+        )));
    }
    start_of_line(remaining)?;
    let (remaining, _leading_whitespace) = space0(remaining)?;
--- a/src/parser/dynamic_block.rs
+++ b/src/parser/dynamic_block.rs
@ -26,7 +26,6 @@ use crate::context::ExitClass;
 use crate::context::ExitMatcherNode;
 use crate::context::RefContext;
 use crate::error::CustomError;
-use crate::error::MyError;
 use crate::error::Res;
 use crate::parser::element_parser::element;
 use crate::parser::util::blank_line;
@ -54,9 +53,9 @@ where
    AK: IntoIterator<Item = Keyword<'s>>,
 {
    if immediate_in_section(context, "dynamic block") {
-        return Err(nom::Err::Error(CustomError::MyError(MyError(
+        return Err(nom::Err::Error(CustomError::Static(
            "Cannot nest objects of the same element",
-        ))));
+        )));
    }

    start_of_line(remaining)?;
--- a/src/parser/element_parser.rs
+++ b/src/parser/element_parser.rs
@ -30,7 +30,6 @@ use super::table::detect_table;
 use crate::context::parser_with_context;
 use crate::context::RefContext;
 use crate::error::CustomError;
-use crate::error::MyError;
 use crate::error::Res;
 use crate::parser::macros::ak_element;
 use crate::parser::macros::element;
@ -251,9 +250,7 @@ fn _element<'b, 'g, 'r, 's>(
        );
    }

-    Err(nom::Err::Error(CustomError::MyError(MyError(
-        "No element.",
-    ))))
+    Err(nom::Err::Error(CustomError::Static("No element.")))
 }

 pub(crate) const fn detect_element(
@ -323,7 +320,5 @@ fn _detect_element<'b, 'g, 'r, 's>(
        return Ok((input, ()));
    }

-    Err(nom::Err::Error(CustomError::MyError(MyError(
-        "No element detected.",
-    ))))
+    Err(nom::Err::Error(CustomError::Static("No element detected.")))
 }
--- a/src/parser/entity.rs
+++ b/src/parser/entity.rs
@ -13,7 +13,6 @@ use super::util::maybe_consume_object_trailing_whitespace_if_not_exiting;
 use crate::context::EntityDefinition;
 use crate::context::RefContext;
 use crate::error::CustomError;
-use crate::error::MyError;
 use crate::error::Res;
 use crate::parser::util::get_consumed;
 use crate::types::Entity;
@ -58,7 +57,7 @@ fn name<'b, 'g, 'r, 's>(
 ) -> Res<OrgSource<'s>, (&'g EntityDefinition<'s>, OrgSource<'s>, bool)> {
    for entity in context.get_global_settings().entities {
        let result = tuple((
-            tag::<_, _, CustomError<_>>(entity.name),
+            tag::<_, _, CustomError>(entity.name),
            alt((
                verify(map(tag("{}"), |_| true), |_| !entity.name.ends_with(' ')),
                map(peek(recognize(entity_end)), |_| false),
@ -69,7 +68,7 @@ fn name<'b, 'g, 'r, 's>(
        }
    }

-    Err(nom::Err::Error(CustomError::MyError(MyError("NoEntity"))))
+    Err(nom::Err::Error(CustomError::Static("NoEntity")))
 }

 #[cfg_attr(feature = "tracing", tracing::instrument(ret, level = "debug"))]
--- a/src/parser/footnote_definition.rs
+++ b/src/parser/footnote_definition.rs
@ -22,7 +22,6 @@ use crate::context::ExitClass;
 use crate::context::ExitMatcherNode;
 use crate::context::RefContext;
 use crate::error::CustomError;
-use crate::error::MyError;
 use crate::error::Res;
 use crate::parser::element_parser::element;
 use crate::parser::util::blank_line;
@ -48,9 +47,9 @@ where
    AK: IntoIterator<Item = Keyword<'s>>,
 {
    if immediate_in_section(context, "footnote definition") {
-        return Err(nom::Err::Error(CustomError::MyError(MyError(
+        return Err(nom::Err::Error(CustomError::Static(
            "Cannot nest objects of the same element",
-        ))));
+        )));
    }
    start_of_line(remaining)?;
    // Cannot be indented.
--- a/src/parser/footnote_reference.rs
+++ b/src/parser/footnote_reference.rs
@ -20,7 +20,6 @@ use crate::context::ExitMatcherNode;
 use crate::context::List;
 use crate::context::RefContext;
 use crate::error::CustomError;
-use crate::error::MyError;
 use crate::error::Res;
 use crate::parser::footnote_definition::label;
 use crate::parser::object_parser::standard_set_object;
@ -176,9 +175,9 @@ fn _footnote_definition_end<'b, 'g, 'r, 's>(
    let current_depth = input.get_bracket_depth() - starting_bracket_depth;
    if current_depth > 0 {
        // Its impossible for the next character to end the footnote reference definition if we're any amount of brackets deep
-        return Err(nom::Err::Error(CustomError::MyError(MyError(
+        return Err(nom::Err::Error(CustomError::Static(
            "NoFootnoteReferenceDefinitionEnd",
-        ))));
+        )));
    }
    if current_depth < 0 {
        // This shouldn't be possible because if depth is 0 then a closing bracket should end the footnote definition.
--- a/src/parser/greater_block.rs
+++ b/src/parser/greater_block.rs
@ -28,7 +28,6 @@ use crate::context::ExitClass;
 use crate::context::ExitMatcherNode;
 use crate::context::RefContext;
 use crate::error::CustomError;
-use crate::error::MyError;
 use crate::error::Res;
 use crate::parser::element_parser::element;
 use crate::parser::util::blank_line;
@ -232,9 +231,9 @@ fn greater_block_body<'c, 'b, 'g, 'r, 's>(
    context_name: &'c str,
 ) -> Res<OrgSource<'s>, (&'s str, Vec<Element<'s>>)> {
    if in_section(context, context_name) {
-        return Err(nom::Err::Error(CustomError::MyError(MyError(
+        return Err(nom::Err::Error(CustomError::Static(
            "Cannot nest objects of the same element",
-        ))));
+        )));
    }
    let exit_with_name = greater_block_end(name);
    let (remaining, _nl) = tuple((space0, line_ending))(input)?;
--- a/src/parser/headline.rs
+++ b/src/parser/headline.rs
@ -29,7 +29,6 @@ use crate::context::ExitClass;
 use crate::context::ExitMatcherNode;
 use crate::context::RefContext;
 use crate::error::CustomError;
-use crate::error::MyError;
 use crate::error::Res;
 use crate::parser::object_parser::standard_set_object;
 use crate::parser::util::blank_line;
@ -260,7 +259,7 @@ fn heading_keyword<'b, 'g, 'r, 's>(
            .iter()
            .map(String::as_str)
        {
-            let result = tag::<_, _, CustomError<_>>(todo_keyword)(input);
+            let result = tag::<_, _, CustomError>(todo_keyword)(input);
            if let Ok((remaining, ent)) = result {
                return Ok((remaining, (TodoKeywordType::Todo, ent)));
            }
@ -270,14 +269,12 @@ fn heading_keyword<'b, 'g, 'r, 's>(
            .iter()
            .map(String::as_str)
        {
-            let result = tag::<_, _, CustomError<_>>(todo_keyword)(input);
+            let result = tag::<_, _, CustomError>(todo_keyword)(input);
            if let Ok((remaining, ent)) = result {
                return Ok((remaining, (TodoKeywordType::Done, ent)));
            }
        }
-        Err(nom::Err::Error(CustomError::MyError(MyError(
-            "NoTodoKeyword",
-        ))))
+        Err(nom::Err::Error(CustomError::Static("NoTodoKeyword")))
    }
 }

@ -288,9 +285,9 @@ fn priority_cookie(input: OrgSource<'_>) -> Res<OrgSource<'_>, PriorityCookie> {
        tag("]"),
    ))(input)?;
    let cookie = PriorityCookie::try_from(priority_character).map_err(|_| {
-        nom::Err::Error(CustomError::MyError(MyError(
+        nom::Err::Error(CustomError::Static(
            "Failed to cast priority cookie to number.",
-        )))
+        ))
    })?;
    Ok((remaining, cookie))
 }
--- a/src/parser/in_buffer_settings.rs
+++ b/src/parser/in_buffer_settings.rs
@ -35,7 +35,7 @@ pub(crate) fn scan_for_in_buffer_settings<'s>(
    let mut remaining = input;
    loop {
        // Skip text until possible in_buffer_setting
-        let start_of_pound = take_until::<_, _, CustomError<_>>("#+")(remaining);
+        let start_of_pound = take_until::<_, _, CustomError>("#+")(remaining);
        let start_of_pound = if let Ok((start_of_pound, _)) = start_of_pound {
            start_of_pound
        } else {
@ -47,7 +47,7 @@ pub(crate) fn scan_for_in_buffer_settings<'s>(
        let (remain, maybe_kw) = match filtered_keyword(in_buffer_settings_key)(start_of_line) {
            Ok((remain, kw)) => (remain, Some(kw)),
            Err(_) => {
-                let end_of_line = take_until::<_, _, CustomError<_>>("\n")(start_of_pound);
+                let end_of_line = take_until::<_, _, CustomError>("\n")(start_of_pound);
                if let Ok((end_of_line, _)) = end_of_line {
                    (end_of_line, None)
                } else {
--- a/src/parser/inline_babel_call.rs
+++ b/src/parser/inline_babel_call.rs
@ -19,7 +19,6 @@ use crate::context::ExitClass;
 use crate::context::ExitMatcherNode;
 use crate::context::RefContext;
 use crate::error::CustomError;
-use crate::error::MyError;
 use crate::error::Res;
 use crate::parser::util::exit_matcher_parser;
 use crate::parser::util::get_consumed;
@ -131,9 +130,7 @@ fn _header_end<'b, 'g, 'r, 's>(
    let current_depth = input.get_bracket_depth() - starting_bracket_depth;
    if current_depth > 0 {
        // Its impossible for the next character to end the header if we're any amount of bracket deep
-        return Err(nom::Err::Error(CustomError::MyError(MyError(
-            "NoHeaderEnd",
-        ))));
+        return Err(nom::Err::Error(CustomError::Static("NoHeaderEnd")));
    }
    if current_depth < 0 {
        // This shouldn't be possible because if depth is 0 then a closing bracket should end the header.
@ -183,9 +180,7 @@ fn _argument_end<'b, 'g, 'r, 's>(
    let current_depth = input.get_parenthesis_depth() - starting_parenthesis_depth;
    if current_depth > 0 {
        // Its impossible for the next character to end the argument if we're any amount of parenthesis deep
-        return Err(nom::Err::Error(CustomError::MyError(MyError(
-            "NoArgumentEnd",
-        ))));
+        return Err(nom::Err::Error(CustomError::Static("NoArgumentEnd")));
    }
    if current_depth < 0 {
        // This shouldn't be possible because if depth is 0 then a closing parenthesis should end the argument.
--- a/src/parser/inline_source_block.rs
+++ b/src/parser/inline_source_block.rs
@ -21,7 +21,6 @@ use crate::context::ExitClass;
 use crate::context::ExitMatcherNode;
 use crate::context::RefContext;
 use crate::error::CustomError;
-use crate::error::MyError;
 use crate::error::Res;
 use crate::parser::util::exit_matcher_parser;
 use crate::parser::util::get_consumed;
@ -125,9 +124,7 @@ fn _header_end<'b, 'g, 'r, 's>(
    let current_depth = input.get_bracket_depth() - starting_bracket_depth;
    if current_depth > 0 {
        // Its impossible for the next character to end the header if we're any amount of bracket deep
-        return Err(nom::Err::Error(CustomError::MyError(MyError(
-            "NoHeaderEnd",
-        ))));
+        return Err(nom::Err::Error(CustomError::Static("NoHeaderEnd")));
    }
    if current_depth < 0 {
        // This shouldn't be possible because if depth is 0 then a closing bracket should end the header.
@ -187,7 +184,7 @@ fn _body_end<'b, 'g, 'r, 's>(
    let current_depth = input.get_brace_depth() - starting_brace_depth;
    if current_depth > 0 {
        // Its impossible for the next character to end the body if we're any amount of brace deep
-        return Err(nom::Err::Error(CustomError::MyError(MyError("NoBodyEnd"))));
+        return Err(nom::Err::Error(CustomError::Static("NoBodyEnd")));
    }
    if current_depth < 0 {
        // This shouldn't be possible because if depth is 0 then a closing brace should end the body.
--- a/src/parser/keyword.rs
+++ b/src/parser/keyword.rs
@ -25,7 +25,6 @@ use super::util::maybe_consume_trailing_whitespace_if_not_exiting;
 use crate::context::parser_with_context;
 use crate::context::RefContext;
 use crate::error::CustomError;
-use crate::error::MyError;
 use crate::error::Res;
 use crate::parser::macros::element;
 use crate::parser::util::start_of_line;
@ -50,10 +49,8 @@ fn _filtered_keyword<'s, F: Fn(OrgSource<'s>) -> Res<OrgSource<'s>, OrgSource<'s
    // TODO: When key is a member of org-element-parsed-keywords, value can contain the standard set objects, excluding footnote references.
    let (remaining, (consumed_input, (_, _, parsed_key, _))) =
        consumed(tuple((space0, tag("#+"), key_parser, tag(":"))))(input)?;
-    if let Ok((remaining, _)) = tuple((
-        space0::<OrgSource<'_>, CustomError<OrgSource<'_>>>,
-        alt((line_ending, eof)),
-    ))(remaining)
+    if let Ok((remaining, _)) =
+        tuple((space0::<_, CustomError>, alt((line_ending, eof))))(remaining)
    {
        return Ok((
            remaining,
@ -152,9 +149,7 @@ fn affiliated_key<'b, 'g, 'r, 's>(
    element!(dual_affiliated_key, context, input);
    element!(plain_affiliated_key, context, input);
    element!(export_keyword, input);
-    Err(nom::Err::Error(CustomError::MyError(MyError(
-        "No affiliated key.",
-    ))))
+    Err(nom::Err::Error(CustomError::Static("No affiliated key.")))
 }

 #[cfg_attr(feature = "tracing", tracing::instrument(ret, level = "debug"))]
@ -164,10 +159,7 @@ fn plain_affiliated_key<'b, 'g, 'r, 's>(
 ) -> Res<OrgSource<'s>, OrgSource<'s>> {
    for keyword in context.get_global_settings().element_affiliated_keywords {
        let result = map(
-            tuple((
-                tag_no_case::<_, _, CustomError<_>>(*keyword),
-                peek(tag(":")),
-            )),
+            tuple((tag_no_case::<_, _, CustomError>(*keyword), peek(tag(":")))),
            |(key, _)| key,
        )(input);
        if let Ok((remaining, ent)) = result {
@ -175,9 +167,7 @@ fn plain_affiliated_key<'b, 'g, 'r, 's>(
        }
    }

-    Err(nom::Err::Error(CustomError::MyError(MyError(
-        "NoKeywordKey",
-    ))))
+    Err(nom::Err::Error(CustomError::Static("NoKeywordKey")))
 }

 #[cfg_attr(feature = "tracing", tracing::instrument(ret, level = "debug"))]
@ -187,7 +177,7 @@ fn dual_affiliated_key<'b, 'g, 'r, 's>(
 ) -> Res<OrgSource<'s>, OrgSource<'s>> {
    for keyword in context.get_global_settings().element_dual_keywords {
        let result = recognize(tuple((
-            tag_no_case::<_, _, CustomError<_>>(*keyword),
+            tag_no_case::<_, _, CustomError>(*keyword),
            tag("["),
            optval,
            tag("]"),
@ -198,9 +188,7 @@ fn dual_affiliated_key<'b, 'g, 'r, 's>(
        }
    }

-    Err(nom::Err::Error(CustomError::MyError(MyError(
-        "NoKeywordKey",
-    ))))
+    Err(nom::Err::Error(CustomError::Static("NoKeywordKey")))
 }

 #[cfg_attr(feature = "tracing", tracing::instrument(ret, level = "debug"))]
@ -228,7 +216,7 @@ fn _optval_end<'s>(
        unreachable!("Exceeded optval bracket depth.")
    }
    if current_depth == 0 {
-        let close_bracket = tag::<_, _, CustomError<_>>("]")(input);
+        let close_bracket = tag::<_, _, CustomError>("]")(input);
        if close_bracket.is_ok() {
            return close_bracket;
        }
--- a/src/parser/latex_fragment.rs
+++ b/src/parser/latex_fragment.rs
@ -17,7 +17,6 @@ use super::util::maybe_consume_object_trailing_whitespace_if_not_exiting;
 use crate::context::parser_with_context;
 use crate::context::RefContext;
 use crate::error::CustomError;
-use crate::error::MyError;
 use crate::error::Res;
 use crate::parser::util::exit_matcher_parser;
 use crate::parser::util::get_consumed;
@ -209,9 +208,9 @@ fn pre<'b, 'g, 'r, 's>(
 ) -> Res<OrgSource<'s>, ()> {
    let preceding_character = input.get_preceding_character();
    if let Some('$') = preceding_character {
-        return Err(nom::Err::Error(CustomError::MyError(MyError(
+        return Err(nom::Err::Error(CustomError::Static(
            "Not a valid pre character for dollar char fragment.",
-        ))));
+        )));
    }
    Ok((input, ()))
 }
@ -283,9 +282,9 @@ fn close_border<'b, 'g, 'r, 's>(
    match preceding_character {
        Some(c) if !c.is_whitespace() && !".,;$".contains(c) => Ok((input, ())),
        _ => {
-            return Err(nom::Err::Error(CustomError::MyError(MyError(
+            return Err(nom::Err::Error(CustomError::Static(
                "Not a valid pre character for dollar char fragment.",
-            ))));
+            )));
        }
    }
 }
--- a/src/parser/lesser_block.rs
+++ b/src/parser/lesser_block.rs
@ -27,7 +27,6 @@ use crate::context::ExitClass;
 use crate::context::ExitMatcherNode;
 use crate::context::RefContext;
 use crate::error::CustomError;
-use crate::error::MyError;
 use crate::error::Res;
 use crate::parser::object_parser::standard_set_object;
 use crate::parser::util::blank_line;
@ -604,7 +603,7 @@ fn _example_src_switches<'s>(
        }
    }
    if !matched_a_word {
-        return Err(nom::Err::Error(CustomError::MyError(MyError("No words."))));
+        return Err(nom::Err::Error(CustomError::Static("No words.")));
    }
    let remaining = last_match_remaining;

--- a/src/parser/line_break.rs
+++ b/src/parser/line_break.rs
@ -7,7 +7,6 @@ use nom::multi::many0;
 use super::org_source::OrgSource;
 use crate::context::RefContext;
 use crate::error::CustomError;
-use crate::error::MyError;
 use crate::error::Res;
 use crate::parser::util::get_consumed;
 use crate::types::LineBreak;
@ -45,9 +44,9 @@ fn pre<'b, 'g, 'r, 's>(
    match preceding_character {
        // If None, we are at the start of the file
        None | Some('\\') => {
-            return Err(nom::Err::Error(CustomError::MyError(MyError(
+            return Err(nom::Err::Error(CustomError::Static(
                "Not a valid pre character for line break.",
-            ))));
+            )));
        }
        _ => {}
    };
@ -55,9 +54,9 @@ fn pre<'b, 'g, 'r, 's>(
    let current_line = input.text_since_line_break();
    let is_non_empty_line = current_line.chars().any(|c| !c.is_whitespace());
    if !is_non_empty_line {
-        return Err(nom::Err::Error(CustomError::MyError(MyError(
+        return Err(nom::Err::Error(CustomError::Static(
            "Not a valid pre line for line break.",
-        ))));
+        )));
    }

    Ok((input, ()))
--- a/src/parser/object_parser.rs
+++ b/src/parser/object_parser.rs
@ -4,7 +4,6 @@ use super::regular_link::regular_link;
 use super::subscript_and_superscript::detect_subscript_or_superscript;
 use crate::context::RefContext;
 use crate::error::CustomError;
-use crate::error::MyError;
 use crate::error::Res;
 use crate::parser::angle_link::angle_link;
 use crate::parser::citation::citation;
@ -43,7 +42,7 @@ pub(crate) fn standard_set_object<'b, 'g, 'r, 's>(
        input,
        Object::PlainText
    );
-    Err(nom::Err::Error(CustomError::MyError(MyError("No object."))))
+    Err(nom::Err::Error(CustomError::Static("No object.")))
 }

 #[cfg_attr(
@ -61,7 +60,7 @@ pub(crate) fn minimal_set_object<'b, 'g, 'r, 's>(
        input,
        Object::PlainText
    );
-    Err(nom::Err::Error(CustomError::MyError(MyError("No object."))))
+    Err(nom::Err::Error(CustomError::Static("No object.")))
 }

 #[cfg_attr(
@ -103,7 +102,7 @@ fn standard_set_object_sans_plain_text<'b, 'g, 'r, 's>(
    element!(angle_link, context, input, Object::AngleLink);
    element!(org_macro, context, input, Object::OrgMacro);

-    Err(nom::Err::Error(CustomError::MyError(MyError("No object."))))
+    Err(nom::Err::Error(CustomError::Static("No object.")))
 }

 #[cfg_attr(
@ -119,7 +118,7 @@ fn minimal_set_object_sans_plain_text<'b, 'g, 'r, 's>(
    element!(entity, context, input, Object::Entity);
    element!(latex_fragment, context, input, Object::LatexFragment);
    element!(text_markup, context, input);
-    Err(nom::Err::Error(CustomError::MyError(MyError("No object."))))
+    Err(nom::Err::Error(CustomError::Static("No object.")))
 }

 #[cfg_attr(
@ -137,9 +136,7 @@ pub(crate) fn detect_standard_set_object_sans_plain_text<'b, 'g, 'r, 's>(
        return Ok((input, ()));
    }

-    return Err(nom::Err::Error(CustomError::MyError(MyError(
-        "No object detected.",
-    ))));
+    return Err(nom::Err::Error(CustomError::Static("No object detected.")));
 }

 #[cfg_attr(
@ -157,9 +154,7 @@ fn detect_minimal_set_object_sans_plain_text<'b, 'g, 'r, 's>(
        return Ok((input, ()));
    }

-    return Err(nom::Err::Error(CustomError::MyError(MyError(
-        "No object detected.",
-    ))));
+    return Err(nom::Err::Error(CustomError::Static("No object detected.")));
 }

 #[cfg_attr(
@ -182,7 +177,7 @@ pub(crate) fn regular_link_description_set_object<'b, 'g, 'r, 's>(
        input,
        Object::PlainText
    );
-    Err(nom::Err::Error(CustomError::MyError(MyError("No object."))))
+    Err(nom::Err::Error(CustomError::Static("No object.")))
 }

 #[cfg_attr(
@ -205,7 +200,7 @@ fn regular_link_description_set_object_sans_plain_text<'b, 'g, 'r, 's>(
    element!(inline_babel_call, context, input, Object::InlineBabelCall);
    element!(org_macro, context, input, Object::OrgMacro);
    element!(minimal_set_object_sans_plain_text, context, input);
-    Err(nom::Err::Error(CustomError::MyError(MyError("No object."))))
+    Err(nom::Err::Error(CustomError::Static("No object.")))
 }

 #[cfg_attr(
@ -223,9 +218,7 @@ fn detect_regular_link_description_set_object_sans_plain_text<'b, 'g, 'r, 's>(
        return Ok((input, ()));
    }

-    Err(nom::Err::Error(CustomError::MyError(MyError(
-        "No object detected.",
-    ))))
+    Err(nom::Err::Error(CustomError::Static("No object detected.")))
 }

 #[cfg_attr(
@ -243,7 +236,7 @@ pub(crate) fn table_cell_set_object<'b, 'g, 'r, 's>(
        input,
        Object::PlainText
    );
-    Err(nom::Err::Error(CustomError::MyError(MyError("No object."))))
+    Err(nom::Err::Error(CustomError::Static("No object.")))
 }

 #[cfg_attr(
@ -271,7 +264,7 @@ fn table_cell_set_object_sans_plain_text<'b, 'g, 'r, 's>(
    element!(target, context, input, Object::Target);
    element!(timestamp, context, input, Object::Timestamp);
    element!(minimal_set_object_sans_plain_text, context, input);
-    Err(nom::Err::Error(CustomError::MyError(MyError("No object."))))
+    Err(nom::Err::Error(CustomError::Static("No object.")))
 }

 #[cfg_attr(
@ -289,7 +282,5 @@ fn detect_table_cell_set_object_sans_plain_text<'b, 'g, 'r, 's>(
        return Ok((input, ()));
    }

-    return Err(nom::Err::Error(CustomError::MyError(MyError(
-        "No object detected.",
-    ))));
+    return Err(nom::Err::Error(CustomError::Static("No object detected.")));
 }
--- a/src/parser/org_macro.rs
+++ b/src/parser/org_macro.rs
@ -96,7 +96,7 @@ fn org_macro_arg<'b, 'g, 'r, 's>(
    loop {
        not(parser_with_context!(exit_matcher_parser)(context))(remaining)?;
        not(peek(tag("}}}")))(remaining)?;
-        if peek(tuple((space0::<OrgSource<'_>, CustomError<_>>, tag(")"))))(remaining).is_ok() {
+        if peek(tuple((space0::<_, CustomError>, tag(")"))))(remaining).is_ok() {
            break;
        }

@ -108,7 +108,7 @@ fn org_macro_arg<'b, 'g, 'r, 's>(
        }
        if next_char == '\\' {
            escaping = true;
-            if peek(tag::<_, _, CustomError<_>>(")"))(new_remaining).is_ok() {
+            if peek(tag::<_, _, CustomError>(")"))(new_remaining).is_ok() {
                // Special case for backslash at the end of a macro
                remaining = new_remaining;
                break;
--- a/src/parser/org_source.rs
+++ b/src/parser/org_source.rs
@ -10,9 +10,6 @@ use nom::InputTakeAtPosition;
 use nom::Offset;
 use nom::Slice;

-use crate::error::CustomError;
-use crate::error::MyError;
-
 pub(crate) type BracketDepth = i16;

 #[derive(Copy, Clone, PartialEq)]
@ -385,33 +382,6 @@ impl<'n, 's> FindSubstring<&'n str> for OrgSource<'s> {
    }
 }

-pub(crate) fn convert_error<'a, I: Into<CustomError<&'a str>>>(
-    err: nom::Err<I>,
-) -> nom::Err<CustomError<&'a str>> {
-    match err {
-        nom::Err::Incomplete(needed) => nom::Err::Incomplete(needed),
-        nom::Err::Error(err) => nom::Err::Error(err.into()),
-        nom::Err::Failure(err) => nom::Err::Failure(err.into()),
-    }
-}
-
-impl<'s> From<CustomError<OrgSource<'s>>> for CustomError<&'s str> {
-    fn from(value: CustomError<OrgSource<'s>>) -> Self {
-        match value {
-            CustomError::MyError(err) => CustomError::MyError(err),
-            CustomError::Nom(input, error_kind) => CustomError::Nom(input.into(), error_kind),
-            CustomError::IO(err) => CustomError::IO(err),
-            CustomError::BoxedError(err) => CustomError::BoxedError(err),
-        }
-    }
-}
-
-impl<'s> From<MyError<OrgSource<'s>>> for MyError<&'s str> {
-    fn from(value: MyError<OrgSource<'s>>) -> Self {
-        MyError(value.0.into())
-    }
-}
-
 #[cfg(test)]
 mod tests {
    use super::*;
--- a/src/parser/plain_link.rs
+++ b/src/parser/plain_link.rs
@ -36,7 +36,6 @@ use crate::context::ExitMatcherNode;
 use crate::context::Matcher;
 use crate::context::RefContext;
 use crate::error::CustomError;
-use crate::error::MyError;
 use crate::error::Res;
 use crate::parser::util::exit_matcher_parser;
 use crate::parser::util::get_consumed;
@ -95,9 +94,9 @@ fn pre<'b, 'g, 'r, 's>(
        Some(x) if !WORD_CONSTITUENT_CHARACTERS.contains(x) => {}
        Some(_) => {
            // Not at start of line, cannot be a heading
-            return Err(nom::Err::Error(CustomError::MyError(MyError(
+            return Err(nom::Err::Error(CustomError::Static(
                "Not a valid pre character for plain link.",
-            ))));
+            )));
        }
    };
    Ok((input, ()))
@ -262,15 +261,13 @@ pub(crate) fn protocol<'b, 'g, 'r, 's>(
    input: OrgSource<'s>,
 ) -> Res<OrgSource<'s>, OrgSource<'s>> {
    for link_parameter in context.get_global_settings().link_parameters {
-        let result = tag_no_case::<_, _, CustomError<_>>(*link_parameter)(input);
+        let result = tag_no_case::<_, _, CustomError>(*link_parameter)(input);
        if let Ok((remaining, ent)) = result {
            return Ok((remaining, ent));
        }
    }

-    Err(nom::Err::Error(CustomError::MyError(MyError(
-        "NoLinkProtocol",
-    ))))
+    Err(nom::Err::Error(CustomError::Static("NoLinkProtocol")))
 }

 #[cfg_attr(
@ -327,8 +324,7 @@ fn impl_path_plain_end<'b, 'g, 'r, 's>(
    }

    if current_depth == 0 {
-        let close_parenthesis =
-            tag::<&str, OrgSource<'_>, CustomError<OrgSource<'_>>>(")")(remaining);
+        let close_parenthesis = tag::<_, _, CustomError>(")")(remaining);
        if close_parenthesis.is_ok() {
            return close_parenthesis;
        }
@ -342,9 +338,7 @@ fn impl_path_plain_end<'b, 'g, 'r, 's>(
        }
    }

-    Err(nom::Err::Error(CustomError::MyError(MyError(
-        "No path plain end",
-    ))))
+    Err(nom::Err::Error(CustomError::Static("No path plain end")))
 }

 #[cfg_attr(
@ -420,18 +414,18 @@ fn _path_plain_parenthesis_end<'s>(
        unreachable!("Exceeded plain link parenthesis depth.")
    }
    if current_depth == 0 {
-        let close_parenthesis = tag::<&str, OrgSource<'_>, CustomError<OrgSource<'_>>>(")")(input);
+        let close_parenthesis = tag::<_, _, CustomError>(")")(input);
        if close_parenthesis.is_ok() {
            return close_parenthesis;
        }
    }
    if current_depth == 1 {
-        let open_parenthesis = tag::<&str, OrgSource<'_>, CustomError<OrgSource<'_>>>("(")(input);
+        let open_parenthesis = tag::<_, _, CustomError>("(")(input);
        if open_parenthesis.is_ok() {
            return open_parenthesis;
        }
    }
-    Err(nom::Err::Error(CustomError::MyError(MyError(
+    Err(nom::Err::Error(CustomError::Static(
        "No closing parenthesis",
-    ))))
+    )))
 }
--- a/src/parser/plain_list.rs
+++ b/src/parser/plain_list.rs
@ -32,7 +32,6 @@ use crate::context::ExitClass;
 use crate::context::ExitMatcherNode;
 use crate::context::RefContext;
 use crate::error::CustomError;
-use crate::error::MyError;
 use crate::error::Res;
 use crate::parser::util::blank_line;
 use crate::parser::util::exit_matcher_parser;
@ -78,9 +77,7 @@ where
    {
        return Ok((input, ()));
    }
-    return Err(nom::Err::Error(CustomError::MyError(MyError(
-        "No element detected.",
-    ))));
+    return Err(nom::Err::Error(CustomError::Static("No element detected.")));
 }

 #[cfg_attr(
@ -152,9 +149,9 @@ where
    let (final_child_start, _final_item_first_parse) = match children.pop() {
        Some(final_child) => final_child,
        None => {
-            return Err(nom::Err::Error(CustomError::MyError(MyError(
+            return Err(nom::Err::Error(CustomError::Static(
                "Plain lists require at least one element.",
-            ))));
+            )));
        }
    };
    let final_item_context = ContextElement::ConsumeTrailingWhitespace(false);
--- a/src/parser/plain_text.rs
+++ b/src/parser/plain_text.rs
@ -20,7 +20,6 @@ use super::util::org_space_or_line_ending;
 use crate::context::parser_with_context;
 use crate::context::RefContext;
 use crate::error::CustomError;
-use crate::error::MyError;
 use crate::error::Res;
 use crate::types::Object;
 use crate::types::PlainText;
@ -92,7 +91,7 @@ impl<'x> RematchObject<'x> for PlainText<'x> {
                break;
            }

-            let is_not_whitespace = is_not::<&str, &str, CustomError<_>>(" \t\r\n")(goal);
+            let is_not_whitespace = is_not::<_, _, CustomError>(" \t\r\n")(goal);
            if let Ok((new_goal, payload)) = is_not_whitespace {
                let (new_remaining, _) = tuple((
                    tag_no_case(payload),
@ -108,7 +107,7 @@ impl<'x> RematchObject<'x> for PlainText<'x> {
            }

            let is_whitespace = recognize(many1(alt((
-                recognize(one_of::<&str, &str, CustomError<_>>(" \t")),
+                recognize(one_of::<_, _, CustomError>(" \t")),
                line_ending,
            ))))(goal);
            if let Ok((new_goal, _)) = is_whitespace {
@ -118,9 +117,9 @@ impl<'x> RematchObject<'x> for PlainText<'x> {
                continue;
            }

-            return Err(nom::Err::Error(CustomError::MyError(MyError(
+            return Err(nom::Err::Error(CustomError::Static(
                "Target does not match.",
-            ))));
+            )));
        }

        let source = get_consumed(input, remaining);
--- a/src/parser/property_drawer.rs
+++ b/src/parser/property_drawer.rs
@ -21,7 +21,6 @@ use crate::context::ExitClass;
 use crate::context::ExitMatcherNode;
 use crate::context::RefContext;
 use crate::error::CustomError;
-use crate::error::MyError;
 use crate::error::Res;
 use crate::parser::util::get_consumed;
 use crate::parser::util::immediate_in_section;
@ -39,9 +38,9 @@ pub(crate) fn property_drawer<'b, 'g, 'r, 's>(
    input: OrgSource<'s>,
 ) -> Res<OrgSource<'s>, PropertyDrawer<'s>> {
    if immediate_in_section(context, "property-drawer") {
-        return Err(nom::Err::Error(CustomError::MyError(MyError(
+        return Err(nom::Err::Error(CustomError::Static(
            "Cannot nest objects of the same element",
-        ))));
+        )));
    }
    let (
        remaining,
--- a/src/parser/radio_link.rs
+++ b/src/parser/radio_link.rs
@ -21,7 +21,6 @@ use crate::context::ExitMatcherNode;
 use crate::context::List;
 use crate::context::RefContext;
 use crate::error::CustomError;
-use crate::error::MyError;
 use crate::error::Res;
 use crate::parser::util::get_consumed;
 use crate::types::Object;
@ -52,9 +51,7 @@ pub(crate) fn radio_link<'b, 'g, 'r, 's>(
            ));
        }
    }
-    Err(nom::Err::Error(CustomError::MyError(MyError(
-        "NoRadioLink",
-    ))))
+    Err(nom::Err::Error(CustomError::Static("NoRadioLink")))
 }

 #[cfg_attr(
@ -98,9 +95,9 @@ pub(crate) fn rematch_target<'x, 'b, 'g, 'r, 's>(
                new_matches.push(new_match);
            }
            _ => {
-                return Err(nom::Err::Error(CustomError::MyError(MyError(
+                return Err(nom::Err::Error(CustomError::Static(
                    "OnlyMinimalSetObjectsAllowed",
-                ))));
+                )));
            }
        };
    }
--- a/src/parser/regular_link.rs
+++ b/src/parser/regular_link.rs
@ -43,7 +43,6 @@ use crate::context::ExitMatcherNode;
 use crate::context::List;
 use crate::context::RefContext;
 use crate::error::CustomError;
-use crate::error::MyError;
 use crate::error::Res;
 use crate::types::LinkType;
 use crate::types::Object;
@ -163,11 +162,7 @@ fn parse_path_reg<'b, 'g, 'r, 's>(
            parser_with_context!(protocol_path_reg)(context),
            fuzzy_path_reg,
        ))(replaced_input)
-        .map_err(|_| {
-            nom::Err::Error(CustomError::MyError(MyError(
-                "No pathreg match after replacement.",
-            )))
-        })?;
+        .map_err(|_| nom::Err::Error(CustomError::Static("No pathreg match after replacement.")))?;
        let remaining = input.take(input.len());
        let link_type = match link.link_type {
            LinkType::Protocol(protocol) => LinkType::Protocol(protocol.into_owned().into()),
@ -483,7 +478,5 @@ fn impl_path_reg_end<'b, 'g, 'r, 's>(
        }
    }

-    Err(nom::Err::Error(CustomError::MyError(MyError(
-        "No path reg end",
-    ))))
+    Err(nom::Err::Error(CustomError::Static("No path reg end")))
 }
--- a/src/parser/subscript_and_superscript.rs
+++ b/src/parser/subscript_and_superscript.rs
@ -26,7 +26,6 @@ use crate::context::ExitMatcherNode;
 use crate::context::Matcher;
 use crate::context::RefContext;
 use crate::error::CustomError;
-use crate::error::MyError;
 use crate::error::Res;
 use crate::parser::util::get_consumed;
 use crate::types::Object;
@ -39,7 +38,7 @@ pub(crate) fn detect_subscript_or_superscript<'s>(input: OrgSource<'s>) -> Res<O
    // This does not have to detect all valid subscript/superscript but all that it detects must be valid.
    let (remaining, _) = one_of("_^")(input)?;
    pre(input)?;
-    if tag::<_, _, CustomError<_>>("*")(remaining).is_ok() {
+    if tag::<_, _, CustomError>("*")(remaining).is_ok() {
        return Ok((input, ()));
    }
    let (remaining, _) = opt(one_of("+-"))(remaining)?;
@ -232,9 +231,9 @@ fn _script_with_braces_end<'b, 'g, 'r, 's>(
    let current_depth = input.get_brace_depth() - starting_brace_depth;
    if current_depth > 0 {
        // Its impossible for the next character to end the subscript or superscript if we're any amount of braces deep
-        return Err(nom::Err::Error(CustomError::MyError(MyError(
+        return Err(nom::Err::Error(CustomError::Static(
            "Not a valid end for subscript or superscript.",
-        ))));
+        )));
    }
    if current_depth < 0 {
        // This shouldn't be possible because if depth is 0 then a closing brace should end the subscript or superscript.
@ -282,12 +281,12 @@ fn _script_with_parenthesis_end<'s>(
        unreachable!("Exceeded citation key suffix bracket depth.")
    }
    if current_depth == 0 {
-        let close_parenthesis = tag::<&str, OrgSource<'_>, CustomError<OrgSource<'_>>>(")")(input);
+        let close_parenthesis = tag::<_, _, CustomError>(")")(input);
        if close_parenthesis.is_ok() {
            return close_parenthesis;
        }
    }
-    Err(nom::Err::Error(CustomError::MyError(MyError(
+    Err(nom::Err::Error(CustomError::Static(
        "No script parenthesis end.",
-    ))))
+    )))
 }
--- a/src/parser/target.rs
+++ b/src/parser/target.rs
@ -13,7 +13,6 @@ use crate::context::ExitClass;
 use crate::context::ExitMatcherNode;
 use crate::context::RefContext;
 use crate::error::CustomError;
-use crate::error::MyError;
 use crate::error::Res;
 use crate::parser::util::get_consumed;
 use crate::types::Target;
@ -42,9 +41,9 @@ pub(crate) fn target<'b, 'g, 'r, 's>(
        .get_preceding_character()
        .expect("We cannot be at the start of the file because we are inside a target.");
    if preceding_character.is_whitespace() {
-        return Err(nom::Err::Error(CustomError::MyError(MyError(
+        return Err(nom::Err::Error(CustomError::Static(
            "Targets cannot end with whitespace.",
-        ))));
+        )));
    }
    let (remaining, _) = tag(">>")(remaining)?;
    let (remaining, _trailing_whitespace) =
--- a/src/parser/text_markup.rs
+++ b/src/parser/text_markup.rs
@ -34,7 +34,6 @@ use crate::context::ExitMatcherNode;
 use crate::context::List;
 use crate::context::RefContext;
 use crate::error::CustomError;
-use crate::error::MyError;
 use crate::error::Res;
 use crate::parser::radio_link::rematch_target;
 use crate::parser::util::exit_matcher_parser;
@ -234,9 +233,9 @@ fn _text_markup_object<'b, 'g, 'r, 's, 'c>(
        #[cfg(feature = "tracing")]
        let _enter = span.enter();
        if exit_matcher_parser(context, remaining).is_ok() {
-            return Err(nom::Err::Error(CustomError::MyError(MyError(
+            return Err(nom::Err::Error(CustomError::Static(
                "Parent exit matcher is triggering.",
-            ))));
+            )));
        }
    }

@ -290,9 +289,9 @@ fn _text_markup_string<'b, 'g, 'r, 's, 'c>(
        #[cfg(feature = "tracing")]
        let _enter = span.enter();
        if exit_matcher_parser(context, remaining).is_ok() {
-            return Err(nom::Err::Error(CustomError::MyError(MyError(
+            return Err(nom::Err::Error(CustomError::Static(
                "Parent exit matcher is triggering.",
-            ))));
+            )));
        }
    }

@ -321,9 +320,9 @@ fn pre<'b, 'g, 'r, 's>(
        // If None, we are at the start of the file which is technically the beginning of a line.
        Some('-') | Some('(') | Some('{') | Some('\'') | Some('"') => {}
        Some(_) => {
-            return Err(nom::Err::Error(CustomError::MyError(MyError(
+            return Err(nom::Err::Error(CustomError::Static(
                "Not a valid pre character for text markup.",
-            ))));
+            )));
        }
        None => unreachable!(), // None is for start of file, which should already be handled by the start_of_line matcher above.
    };
@ -360,9 +359,9 @@ fn _text_markup_end<'b, 'g, 'r, 's, 'c>(
    contents_start_offset: usize,
 ) -> Res<OrgSource<'s>, OrgSource<'s>> {
    if input.get_byte_offset() == contents_start_offset {
-        return Err(nom::Err::Error(CustomError::MyError(MyError(
+        return Err(nom::Err::Error(CustomError::Static(
            "Text markup cannot be empty",
-        ))));
+        )));
    }
    not(preceded_by_whitespace(false))(input)?;
    let (remaining, _marker) = terminated(
@ -495,9 +494,9 @@ fn _rematch_text_markup_object<'b, 'g, 'r, 's, 'x>(
        #[cfg(feature = "tracing")]
        let _enter = span.enter();
        if exit_matcher_parser(context, remaining).is_ok() {
-            return Err(nom::Err::Error(CustomError::MyError(MyError(
+            return Err(nom::Err::Error(CustomError::Static(
                "Parent exit matcher is triggering.",
-            ))));
+            )));
        }
    }

--- a/src/parser/util.rs
+++ b/src/parser/util.rs
@ -20,7 +20,6 @@ use crate::context::parser_with_context;
 use crate::context::ContextElement;
 use crate::context::RefContext;
 use crate::error::CustomError;
-use crate::error::MyError;
 use crate::error::Res;
 use crate::types::IndentationLevel;

@ -129,9 +128,7 @@ pub(crate) fn start_of_line<'s>(input: OrgSource<'s>) -> Res<OrgSource<'s>, ()>
    if input.is_at_start_of_line() {
        Ok((input, ()))
    } else {
-        Err(nom::Err::Error(CustomError::MyError(MyError(
-            "Not at start of line",
-        ))))
+        Err(nom::Err::Error(CustomError::Static("Not at start of line")))
    }
 }

@ -152,9 +149,9 @@ fn _preceded_by_whitespace<'s>(
        .map(|c| c.is_whitespace() || c == '\u{200B}') // 200B = Zero-width space
        .unwrap_or(allow_start_of_file)
    {
-        return Err(nom::Err::Error(CustomError::MyError(MyError(
+        return Err(nom::Err::Error(CustomError::Static(
            "Must be preceded by a whitespace character.",
-        ))));
+        )));
    }
    Ok((input, ()))
 }
@ -195,9 +192,7 @@ pub(crate) fn text_until_exit<'b, 'g, 'r, 's>(

 #[allow(dead_code)]
 fn not_yet_implemented() -> Res<OrgSource<'static>, ()> {
-    Err(nom::Err::Error(CustomError::MyError(MyError(
-        "Not implemented yet.",
-    ))))
+    Err(nom::Err::Error(CustomError::Static("Not implemented yet.")))
 }

 #[allow(dead_code)]
@ -205,9 +200,7 @@ fn not_yet_implemented() -> Res<OrgSource<'static>, ()> {
 /// Text from the current point until the next line break or end of file
 ///
 /// Useful for debugging.
-fn text_until_eol<'r, 's>(
-    input: OrgSource<'s>,
-) -> Result<&'s str, nom::Err<CustomError<OrgSource<'s>>>> {
+fn text_until_eol<'r, 's>(input: OrgSource<'s>) -> Result<&'s str, nom::Err<CustomError>> {
    let line = recognize(many_till(anychar, alt((line_ending, eof))))(input)
        .map(|(_remaining, line)| Into::<&str>::into(line))?;
    Ok(line.trim())