links_notation/

lib.rs

pub mod binary;
pub mod comments;
pub mod cst;
pub mod format_config;
pub mod parser;
pub mod parser_config;
mod quotes;
pub mod reference_literal;
pub use reference_literal::{decode_reference_literal, encode_reference_literal};
pub mod stream_parser;
pub mod syntax;

use comments::strip_comments;
pub use cst::{CstKind, CstNode, parse_lino_to_cst, parse_lino_to_cst_with_config};
use format_config::FormatConfig;
pub use parser_config::ParserConfig;
use std::borrow::Cow;
pub use stream_parser::{
    ErrorLocation, StreamIterator, StreamParseError, StreamParser, StreamPosition, StreamReference,
};
pub use syntax::{SyntaxReference, reference_quote};

// Re-export the lino! macro when the macro feature is enabled
#[cfg(feature = "macro")]
pub use links_notation_macro::lino;
use std::error::Error as StdError;
use std::fmt;

/// The version of this crate, taken from `Cargo.toml` at compile time.
///
/// A tool that reports which parser produced a result should read it from here
/// rather than from its own package, which is how the benchmark report came to
/// claim the version of the benchmark instead of the version of the parser.
///
/// # Examples
/// ```
/// assert!(!links_notation::VERSION.is_empty());
/// ```
pub const VERSION: &str = env!("CARGO_PKG_VERSION");

/// Error type for Lino parsing
#[derive(Debug)]
pub enum ParseError {
    /// Input string is empty or contains only whitespace
    EmptyInput,
    /// The document does not parse, and this is where it stopped
    SyntaxError(SyntaxError),
    /// The document nests links deeper than [`ParserConfig::max_depth`], and
    /// this is where the level that is one too deep opens
    NestingTooDeep(NestingTooDeep),
    /// Internal parser error
    InternalError(String),
}

impl fmt::Display for ParseError {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        match self {
            ParseError::EmptyInput => write!(f, "Empty input"),
            ParseError::SyntaxError(error) => write!(f, "Syntax error at {}", error),
            ParseError::NestingTooDeep(error) => write!(f, "Nesting too deep at {}", error),
            ParseError::InternalError(msg) => write!(f, "Internal error: {}", msg),
        }
    }
}

impl StdError for ParseError {}

/// The number of characters of the offending line an error message quotes.
///
/// A message has to fit in a log line, and the whole point of quoting one line
/// of context is that the message does not grow with the size of the document.
const QUOTED_LINE_WIDTH: usize = 80;

/// What a message writes in place of the part of a long line it left out.
const ELLIPSIS: &str = "...";

/// A syntax error, with the position in the document it was found at.
///
/// The position is the furthest one the parser reached, which is the character
/// the document stops making sense at rather than the point the last
/// alternative gave up on.
///
/// # Examples
/// ```
/// use links_notation::{parse_lino, ParseError};
///
/// let error = parse_lino("ci_gate x\nstage: rust: nextest\n").unwrap_err();
/// let ParseError::SyntaxError(error) = error else { panic!("expected a syntax error") };
/// assert_eq!((error.line, error.column), (2, 12));
/// assert_eq!(error.found, Some(':'));
/// ```
#[derive(Debug, Clone, PartialEq, Eq)]
pub struct SyntaxError {
    /// Byte offset of the offending position from the start of the document.
    pub offset: usize,
    /// Line the offending position is on, counted from 1.
    pub line: usize,
    /// Column the offending position is at, in characters, counted from 1.
    pub column: usize,
    /// What could have continued the document at this position. Empty when the
    /// parser stopped somewhere it names no expectation for.
    pub expected: Vec<String>,
    /// The character found instead, or `None` at the end of the document.
    pub found: Option<char>,
    /// The offending line, as written, without its line ending.
    pub line_text: String,
}

impl SyntaxError {
    /// The one-line summary: where the parser stopped, what could have stood
    /// there and what does.
    ///
    /// # Examples
    /// ```
    /// use links_notation::{parse_lino, ParseError};
    ///
    /// let ParseError::SyntaxError(error) = parse_lino("a: b: c").unwrap_err() else {
    ///     panic!("expected a syntax error")
    /// };
    /// assert_eq!(
    ///     error.summary(),
    ///     r#"line 1, column 5: expected "(", a reference or end of line, found ":""#
    /// );
    /// ```
    pub fn summary(&self) -> String {
        let found = match self.found {
            Some(character) => format!("\"{}\"", character.escape_debug()),
            None => "end of input".to_string(),
        };
        match join_alternatives(&self.expected) {
            Some(expected) => format!(
                "line {}, column {}: expected {}, found {}",
                self.line, self.column, expected, found
            ),
            None => format!(
                "line {}, column {}: unexpected {}",
                self.line, self.column, found
            ),
        }
    }

    /// The offending line with a caret under the offending column, quoted the
    /// way `rustc` quotes source.
    ///
    /// A long line is shown as a window around the caret, so the message stays
    /// the same size whether the document has ten lines or fifteen hundred.
    ///
    /// # Examples
    /// ```
    /// use links_notation::{parse_lino, ParseError};
    ///
    /// let ParseError::SyntaxError(error) = parse_lino("a: b: c").unwrap_err() else {
    ///     panic!("expected a syntax error")
    /// };
    /// assert_eq!(error.snippet(), "1 | a: b: c\n  |     ^");
    /// ```
    pub fn snippet(&self) -> String {
        snippet(self.line, &self.line_text, self.column)
    }
}

impl fmt::Display for SyntaxError {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        write!(f, "{}\n{}", self.summary(), self.snippet())
    }
}

impl StdError for SyntaxError {}

/// A document that nests links deeper than the parser allows, with the position
/// of the level that is one too deep.
///
/// Every parenthesized group and every indentation level is one level of
/// nesting. The parser recurses once per level, so the limit is what turns a
/// document that would overflow the stack, and abort the process, into an error.
///
/// # Examples
/// ```
/// use links_notation::{parse_lino_with_config, ParseError, ParserConfig};
///
/// let config = ParserConfig::new().with_max_depth(1);
/// assert!(parse_lino_with_config("(a (b))", &config).is_err());
/// let Err(ParseError::NestingTooDeep(error)) = parse_lino_with_config("((a))", &config) else {
///     panic!("expected the nesting to be too deep")
/// };
/// assert_eq!((error.max_depth, error.line, error.column), (1, 1, 2));
/// assert_eq!(
///     error.to_string(),
///     "line 1, column 2: nesting depth exceeds the maximum of 1\n1 | ((a))\n  |  ^"
/// );
/// ```
#[derive(Debug, Clone, PartialEq, Eq)]
pub struct NestingTooDeep {
    /// The deepest nesting the parser was configured to accept.
    pub max_depth: usize,
    /// Byte offset of the offending position from the start of the document.
    pub offset: usize,
    /// Line the offending position is on, counted from 1.
    pub line: usize,
    /// Column the offending position is at, in characters, counted from 1.
    pub column: usize,
    /// The offending line, as written, without its line ending.
    pub line_text: String,
}

impl NestingTooDeep {
    /// The one-line summary: where the nesting got too deep and how deep it may go.
    pub fn summary(&self) -> String {
        format!(
            "line {}, column {}: nesting depth exceeds the maximum of {}",
            self.line, self.column, self.max_depth
        )
    }

    /// The offending line with a caret under the offending column.
    pub fn snippet(&self) -> String {
        snippet(self.line, &self.line_text, self.column)
    }
}

impl fmt::Display for NestingTooDeep {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        write!(f, "{}\n{}", self.summary(), self.snippet())
    }
}

impl StdError for NestingTooDeep {}

/// Quotes line `number` with a caret under `column`, the way `rustc` quotes
/// source.
fn snippet(number: usize, line_text: &str, column: usize) -> String {
    let (quoted, column) = quote_line(line_text, column);
    let number = number.to_string();
    let gutter = " ".repeat(number.len());
    format!(
        "{} | {}\n{} | {}^",
        number,
        quoted,
        gutter,
        " ".repeat(column - 1)
    )
}

/// Writes alternatives the way prose does: `a`, `a or b`, `a, b or c`.
fn join_alternatives(alternatives: &[String]) -> Option<String> {
    match alternatives {
        [] => None,
        [only] => Some(only.clone()),
        [rest @ .., last] => Some(format!("{} or {}", rest.join(", "), last)),
    }
}

/// Cuts `line` down to a window around `column`, and says which column the
/// offending character sits at in that window. Both columns count from 1.
fn quote_line(line: &str, column: usize) -> (String, usize) {
    let characters: Vec<char> = line.chars().collect();
    if characters.len() <= QUOTED_LINE_WIDTH {
        return (line.to_string(), column);
    }

    let target = column - 1;
    let last_start = characters.len() - QUOTED_LINE_WIDTH;
    let start = target.saturating_sub(QUOTED_LINE_WIDTH / 2).min(last_start);
    let end = start + QUOTED_LINE_WIDTH;

    let mut quoted = String::new();
    if start > 0 {
        quoted.push_str(ELLIPSIS);
    }
    quoted.extend(&characters[start..end]);
    if end < characters.len() {
        quoted.push_str(ELLIPSIS);
    }

    let shift = if start > 0 {
        ELLIPSIS.chars().count()
    } else {
        0
    };
    (quoted, target - start + shift + 1)
}

/// Turns the position the parser stopped at into a line, a column and the line
/// itself, so the message can point at the defect instead of quoting the rest
/// of the document.
fn locate(document: &str, failure: parser::ParseFailure) -> SyntaxError {
    let offset = failure.offset.min(document.len());
    let mut line = 1;
    let mut line_start = 0;
    let bytes = document.as_bytes();
    let mut cursor = 0;
    while cursor < offset {
        match bytes[cursor] {
            b'\r' => {
                line += 1;
                cursor += 1;
                if cursor < offset && bytes[cursor] == b'\n' {
                    cursor += 1;
                }
                line_start = cursor;
            }
            b'\n' => {
                line += 1;
                cursor += 1;
                line_start = cursor;
            }
            _ => cursor += 1,
        }
    }
    let column = document[line_start..offset].chars().count() + 1;
    let line_end = document[line_start..]
        .find(['\r', '\n'])
        .map_or(document.len(), |position| line_start + position);
    let line_text = &document[line_start..line_end];

    SyntaxError {
        offset,
        line,
        column,
        expected: failure.expected.iter().map(|s| s.to_string()).collect(),
        found: document[offset..].chars().next(),
        line_text: line_text.to_string(),
    }
}

/// Turns a failed parse into the error the caller sees.
fn parse_error(document: &str, failure: parser::ParseFailure) -> ParseError {
    let max_depth = failure.max_depth_exceeded;
    let located = locate(document, failure);
    match max_depth {
        Some(max_depth) => ParseError::NestingTooDeep(NestingTooDeep {
            max_depth,
            offset: located.offset,
            line: located.line,
            column: located.column,
            line_text: located.line_text,
        }),
        None => ParseError::SyntaxError(located),
    }
}

#[derive(Debug, Clone, PartialEq)]
pub enum LiNo<T> {
    Link { id: Option<T>, values: Vec<Self> },
    Ref(T),
}

impl<T> LiNo<T> {
    pub fn is_ref(&self) -> bool {
        matches!(self, LiNo::Ref(_))
    }

    pub fn is_link(&self) -> bool {
        matches!(self, LiNo::Link { .. })
    }

    /// Creates a new link with the given ID and values.
    ///
    /// This method allows creating links with any number of values,
    /// providing an alternative to tuple conversion for cases where
    /// more than 12 values are needed.
    ///
    /// # Examples
    /// ```
    /// use links_notation::LiNo;
    ///
    /// // Create a link with many values
    /// let values: Vec<LiNo<String>> = (1..=20)
    ///     .map(|i| LiNo::Ref(format!("v{}", i)))
    ///     .collect();
    /// let link = LiNo::new(Some("id".to_string()), values);
    /// ```
    pub fn new(id: Option<T>, values: Vec<Self>) -> Self {
        LiNo::Link { id, values }
    }

    /// Creates a new anonymous link (no ID) with the given values.
    ///
    /// # Examples
    /// ```
    /// use links_notation::LiNo;
    ///
    /// let values = vec![LiNo::Ref("a".to_string()), LiNo::Ref("b".to_string())];
    /// let link = LiNo::anonymous(values);
    /// assert_eq!(format!("{}", link), "(a b)");
    /// ```
    pub fn anonymous(values: Vec<Self>) -> Self {
        LiNo::Link { id: None, values }
    }

    /// Creates a new reference.
    ///
    /// # Examples
    /// ```
    /// use links_notation::LiNo;
    ///
    /// let r: LiNo<String> = LiNo::reference("hello".to_string());
    /// assert_eq!(format!("{}", r), "hello");
    /// ```
    pub fn reference(value: T) -> Self {
        LiNo::Ref(value)
    }
}

/// Builder for creating LiNo links with arbitrary number of values.
///
/// This builder provides a fluent API for constructing links when the tuple
/// conversion (limited to 12 elements) is insufficient.
///
/// # Examples
/// ```
/// use links_notation::{LiNo, LiNoBuilder};
///
/// // Build a link with many string values
/// let link: LiNo<String> = LiNoBuilder::new()
///     .id("myLink")
///     .value("v1")
///     .value("v2")
///     .value("v3")
///     .build();
/// assert_eq!(format!("{}", link), "(myLink: v1 v2 v3)");
///
/// // Build a link with LiNo values
/// let nested: LiNo<String> = ("inner", "a", "b").into();
/// let link: LiNo<String> = LiNoBuilder::new()
///     .id("outer")
///     .lino(nested)
///     .value("c")
///     .build();
/// assert_eq!(format!("{}", link), "(outer: (inner: a b) c)");
///
/// // Build anonymous link
/// let link: LiNo<String> = LiNoBuilder::new()
///     .value("a")
///     .value("b")
///     .build();
/// assert_eq!(format!("{}", link), "(a b)");
/// ```
#[derive(Debug, Clone, Default)]
pub struct LiNoBuilder {
    id: Option<String>,
    values: Vec<LiNo<String>>,
}

impl LiNoBuilder {
    /// Creates a new empty LiNoBuilder.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the ID of the link.
    ///
    /// If called multiple times, the last value wins.
    pub fn id(mut self, id: &str) -> Self {
        self.id = Some(id.to_string());
        self
    }

    /// Adds a string value to the link (converted to a Ref).
    pub fn value(mut self, value: &str) -> Self {
        self.values.push(LiNo::Ref(value.to_string()));
        self
    }

    /// Adds a LiNo value to the link.
    pub fn lino(mut self, value: LiNo<String>) -> Self {
        self.values.push(value);
        self
    }

    /// Adds multiple string values to the link.
    pub fn values<I, S>(mut self, values: I) -> Self
    where
        I: IntoIterator<Item = S>,
        S: AsRef<str>,
    {
        for v in values {
            self.values.push(LiNo::Ref(v.as_ref().to_string()));
        }
        self
    }

    /// Adds multiple LiNo values to the link.
    pub fn linos<I>(mut self, values: I) -> Self
    where
        I: IntoIterator<Item = LiNo<String>>,
    {
        self.values.extend(values);
        self
    }

    /// Builds the final LiNo link.
    pub fn build(self) -> LiNo<String> {
        LiNo::Link {
            id: self.id,
            values: self.values,
        }
    }
}

/// Type alias for backward compatibility (deprecated).
#[deprecated(since = "0.3.0", note = "Use LiNoBuilder instead")]
pub type LinkBuilder = LiNoBuilder;

impl<T: ToString + Clone> LiNo<T> {
    /// Format the link using FormatConfig configuration.
    ///
    /// # Arguments
    /// * `config` - The FormatConfig to use for formatting
    ///
    /// # Returns
    /// Formatted string representation
    pub fn format_with_config(&self, config: &FormatConfig) -> String {
        match self {
            LiNo::Ref(value) => {
                let escaped = escape_reference(&value.to_string());
                if config.less_parentheses {
                    escaped
                } else {
                    format!("({})", escaped)
                }
            }
            LiNo::Link { id, values } => {
                // Empty link
                if id.is_none() && values.is_empty() {
                    return if config.less_parentheses {
                        String::new()
                    } else {
                        "()".to_string()
                    };
                }

                // Link with only ID, no values
                if values.is_empty() {
                    if let Some(id_val) = id {
                        let escaped_id = escape_reference(&id_val.to_string());
                        return if config.less_parentheses && !needs_parentheses(&id_val.to_string())
                        {
                            escaped_id
                        } else {
                            format!("({})", escaped_id)
                        };
                    }
                    return if config.less_parentheses {
                        String::new()
                    } else {
                        "()".to_string()
                    };
                }

                // Check if we should use indented format
                let mut should_indent = false;
                if config.should_indent_by_ref_count(values.len()) {
                    should_indent = true;
                } else {
                    // Try inline format first to check line length
                    let values_str = values
                        .iter()
                        .map(|v| format_value(v))
                        .collect::<Vec<_>>()
                        .join(" ");

                    let test_line = if let Some(id_val) = id {
                        let id_str = escape_reference(&id_val.to_string());
                        if config.less_parentheses {
                            format!("{}: {}", id_str, values_str)
                        } else {
                            format!("({}: {})", id_str, values_str)
                        }
                    } else if config.less_parentheses {
                        values_str.clone()
                    } else {
                        format!("({})", values_str)
                    };

                    if config.should_indent_by_length(&test_line) {
                        should_indent = true;
                    }
                }

                // Format with indentation if needed
                if should_indent && !config.prefer_inline {
                    return self.format_indented(config);
                }

                // Standard inline formatting
                let values_str = values
                    .iter()
                    .map(|v| format_value(v))
                    .collect::<Vec<_>>()
                    .join(" ");

                // Link with values only (null id)
                if id.is_none() {
                    if config.less_parentheses {
                        // Check if all values are simple (no nested values)
                        let all_simple = values.iter().all(|v| matches!(v, LiNo::Ref(_)));
                        if all_simple {
                            return values
                                .iter()
                                .map(|v| match v {
                                    LiNo::Ref(r) => escape_reference(&r.to_string()),
                                    _ => format_value(v),
                                })
                                .collect::<Vec<_>>()
                                .join(" ");
                        }
                        return values_str;
                    }
                    return format!("({})", values_str);
                }

                // Link with ID and values
                let id_str = escape_reference(&id.as_ref().unwrap().to_string());
                let with_colon = format!("{}: {}", id_str, values_str);
                if config.less_parentheses && !needs_parentheses(&id.as_ref().unwrap().to_string())
                {
                    with_colon
                } else {
                    format!("({})", with_colon)
                }
            }
        }
    }

    /// Format the link with indentation.
    fn format_indented(&self, config: &FormatConfig) -> String {
        match self {
            LiNo::Ref(value) => {
                let escaped = escape_reference(&value.to_string());
                format!("({})", escaped)
            }
            LiNo::Link { id, values } => {
                if id.is_none() {
                    // Values only - format each on separate line
                    values
                        .iter()
                        .map(|v| format!("{}{}", config.indent_string, format_value(v)))
                        .collect::<Vec<_>>()
                        .join("\n")
                } else {
                    // Link with ID - format as id:\n  value1\n  value2
                    let id_str = escape_reference(&id.as_ref().unwrap().to_string());
                    let mut lines = vec![format!("{}:", id_str)];
                    for v in values {
                        lines.push(format!("{}{}", config.indent_string, format_value(v)));
                    }
                    lines.join("\n")
                }
            }
        }
    }
}

impl<T: ToString> fmt::Display for LiNo<T> {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        match self {
            LiNo::Ref(value) => write!(f, "{}", escape_reference(&value.to_string())),
            LiNo::Link { id, values } => {
                let id_str = id
                    .as_ref()
                    .map(|id| format!("{}: ", escape_reference(&id.to_string())))
                    .unwrap_or_default();

                if f.alternate() {
                    // Format top-level as lines
                    let lines = values
                        .iter()
                        .map(|value| {
                            // For alternate formatting, ensure standalone references are wrapped in parentheses
                            // so that flattened structures like indented blocks render as "(ref)" lines
                            match value {
                                LiNo::Ref(_) => format!("{}({})", id_str, value),
                                _ => format!("{}{}", id_str, value),
                            }
                        })
                        .collect::<Vec<_>>()
                        .join("\n");
                    write!(f, "{}", lines)
                } else {
                    let values_str = values
                        .iter()
                        .map(|value| value.to_string())
                        .collect::<Vec<_>>()
                        .join(" ");
                    write!(f, "({}{})", id_str, values_str)
                }
            }
        }
    }
}

impl LiNo<SyntaxReference> {
    /// The same link with plain IDs, which is what the AST mode reads: every
    /// [`SyntaxReference`] becomes its [`value`](SyntaxReference::value).
    ///
    /// # Examples
    /// ```
    /// use links_notation::{LiNo, parse_lino_to_links, parse_lino_to_syntax_links};
    ///
    /// let syntax = parse_lino_to_syntax_links("('a': \"b\")").unwrap();
    /// let plain: LiNo<String> = syntax[0].clone().into_values();
    /// assert_eq!(plain, parse_lino_to_links("(a: b)").unwrap()[0]);
    /// assert_eq!(LiNo::<String>::from(syntax[0].clone()), plain);
    /// ```
    pub fn into_values(self) -> LiNo<String> {
        match self {
            LiNo::Ref(reference) => LiNo::Ref(reference.value),
            LiNo::Link { id, values } => LiNo::Link {
                id: id.map(|id| id.value),
                values: values.into_iter().map(LiNo::into_values).collect(),
            },
        }
    }

    /// The ID exactly as the document wrote it: the text of a reference, or of
    /// a link's ID. `None` for a link without an ID and for a reference built
    /// in code.
    ///
    /// # Examples
    /// ```
    /// use links_notation::{LiNo, parse_lino_to_syntax_links};
    ///
    /// let links = parse_lino_to_syntax_links("'a': ~1{62}").unwrap();
    /// assert_eq!(links[0].raw_id(), Some("'a'"));
    /// let LiNo::Link { values, .. } = &links[0] else { unreachable!() };
    /// assert_eq!(values[0].raw_id(), Some("~1{62}"));
    /// ```
    pub fn raw_id(&self) -> Option<&str> {
        match self {
            LiNo::Ref(reference) => reference.raw.as_deref(),
            LiNo::Link { id, .. } => id.as_ref().and_then(|id| id.raw.as_deref()),
        }
    }

    /// The delimiter the ID was written between: `'`, `"` or `` ` `` when it
    /// was quoted, and `None` otherwise; see [`SyntaxReference::quote`].
    pub fn quote(&self) -> Option<char> {
        self.raw_id().and_then(reference_quote)
    }
}

/// Drops how the IDs were written; see [`LiNo::into_values`].
impl From<LiNo<SyntaxReference>> for LiNo<String> {
    fn from(link: LiNo<SyntaxReference>) -> Self {
        link.into_values()
    }
}

// Convert from parser::Link to LiNo (without flattening)
impl From<parser::Link> for LiNo<String> {
    fn from(link: parser::Link) -> Self {
        if let Some(body) = &link.nested {
            return transform_nested(body, &plain_id);
        }
        if link.values.is_empty() && link.children.is_empty() {
            if let Some(id) = link.id {
                LiNo::Ref(id)
            } else {
                LiNo::Link {
                    id: None,
                    values: vec![],
                }
            }
        } else {
            let values: Vec<LiNo<String>> = link.values.into_iter().map(|v| v.into()).collect();
            LiNo::Link {
                id: link.id,
                values,
            }
        }
    }
}

/// How the links of a parsed document get their IDs: as the plain value, or as
/// a [`SyntaxReference`] that also records how the ID was written.
trait IdReader<T>: Fn(&parser::Link) -> Option<T> {}

impl<T, F: Fn(&parser::Link) -> Option<T>> IdReader<T> for F {}

/// The ID of a parsed link, as its plain value.
fn plain_id(link: &parser::Link) -> Option<String> {
    link.id.clone()
}

/// The ID of a parsed link with the text it was written as, sliced from the
/// document the caller passed in rather than from the comment-blanked copy the
/// parser read, which keeps every byte where it was.
fn syntax_id(link: &parser::Link, document: &str) -> Option<SyntaxReference> {
    let value = link.id.clone()?;
    let raw = link
        .id_span
        .as_ref()
        .and_then(|span| document.get(span.clone()))
        .map(str::to_owned);
    Some(SyntaxReference { value, raw })
}

// A parenthesized group is a nested document: its body follows the same rules as
// the root, so it is flattened the same way. A body that produces a single link
// collapses to that link, unless the body is a single parenthesized group, which
// keeps `((a b))` different from `(a b)`.
//
// The body is borrowed, not copied: copying it at every level would copy the
// levels below once per level above them, which is quadratic in the nesting.
fn transform_nested<T: Clone, F: IdReader<T>>(body: &[parser::Link], id: &F) -> LiNo<T> {
    let links = flatten_links(body, id);
    let wraps_single_group =
        body.len() == 1 && body[0].nested.is_some() && body[0].children.is_empty();
    if links.len() == 1 && !wraps_single_group {
        return links.into_iter().next().unwrap();
    }
    LiNo::Link {
        id: None,
        values: links,
    }
}

// Helper function to flatten indented structures according to Lino spec
fn flatten_links<T: Clone, F: IdReader<T>>(links: &[parser::Link], id: &F) -> Vec<LiNo<T>> {
    let mut result = vec![];

    for link in links {
        flatten_link_recursive(link, None, &mut result, id);
    }

    result
}

fn flatten_link_recursive<T: Clone, F: IdReader<T>>(
    link: &parser::Link,
    parent: Option<&LiNo<T>>,
    result: &mut Vec<LiNo<T>>,
    id: &F,
) {
    // Special case: If this is an indented ID (with colon) with children,
    // the children should become the values of the link (indented ID syntax)
    if link.is_indented_id
        && link.id.is_some()
        && link.values.is_empty()
        && !link.children.is_empty()
    {
        let child_values: Vec<LiNo<T>> = link
            .children
            .iter()
            .map(|child| transform_indented_value(child, id))
            .collect();

        let current = LiNo::Link {
            id: id(link),
            values: child_values,
        };

        let combined = if let Some(parent) = parent {
            // Wrap parent in parentheses if it's a reference
            let wrapped_parent = match parent {
                LiNo::Ref(ref_id) => LiNo::Link {
                    id: None,
                    values: vec![LiNo::Ref(ref_id.clone())],
                },
                link => link.clone(),
            };

            LiNo::Link {
                id: None,
                values: vec![wrapped_parent, current],
            }
        } else {
            current
        };

        result.push(combined);
        return; // Don't process children again
    }

    // Create the current link without children
    let current = if let Some(body) = &link.nested {
        transform_nested(body, id)
    } else if link.values.is_empty() {
        if let Some(id) = id(link) {
            LiNo::Ref(id)
        } else {
            LiNo::Link {
                id: None,
                values: vec![],
            }
        }
    } else {
        LiNo::Link {
            id: id(link),
            values: link
                .values
                .iter()
                .map(|value| transform_value(value, id))
                .collect(),
        }
    };

    // Create the combined link (parent + current) with proper wrapping
    let combined = if let Some(parent) = parent {
        // Wrap parent in parentheses if it's a reference
        let wrapped_parent = match parent {
            LiNo::Ref(ref_id) => LiNo::Link {
                id: None,
                values: vec![LiNo::Ref(ref_id.clone())],
            },
            link => link.clone(),
        };

        // Wrap current in parentheses if it's a reference
        let wrapped_current = match current {
            LiNo::Ref(ref_id) => LiNo::Link {
                id: None,
                values: vec![LiNo::Ref(ref_id)],
            },
            link => link,
        };

        LiNo::Link {
            id: None,
            values: vec![wrapped_parent, wrapped_current],
        }
    } else {
        current
    };

    // Only a link with children needs a copy: each child repeats it as its
    // parent. Copying it regardless would copy every nested group once per
    // level above it.
    if link.children.is_empty() {
        result.push(combined);
        return;
    }
    result.push(combined.clone());

    // Process children
    for child in &link.children {
        flatten_link_recursive(child, Some(&combined), result, id);
    }
}

// Convert a link without its indented children, borrowing the parsed tree.
fn transform_value<T: Clone, F: IdReader<T>>(link: &parser::Link, id: &F) -> LiNo<T> {
    if let Some(body) = &link.nested {
        return transform_nested(body, id);
    }
    if link.values.is_empty() {
        return match id(link) {
            Some(id) => LiNo::Ref(id),
            None => LiNo::Link {
                id: None,
                values: vec![],
            },
        };
    }
    LiNo::Link {
        id: id(link),
        values: link
            .values
            .iter()
            .map(|value| transform_value(value, id))
            .collect(),
    }
}

// Convert a child line and all its descendants into one value of an indented ID.
fn transform_indented_value<T: Clone, F: IdReader<T>>(link: &parser::Link, id: &F) -> LiNo<T> {
    let children: Vec<_> = link
        .children
        .iter()
        .map(|child| transform_indented_value(child, id))
        .collect();
    if !children.is_empty() && link.is_indented_id && link.id.is_some() && link.values.is_empty() {
        return LiNo::Link {
            id: id(link),
            values: children,
        };
    }
    let current = transform_value(link, id);

    if !children.is_empty() {
        match current {
            LiNo::Link { id, mut values } => {
                values.extend(children);
                LiNo::Link { id, values }
            }
            LiNo::Ref(id) => {
                if link.nested.is_some() {
                    return LiNo::Link {
                        id: Some(id),
                        values: children,
                    };
                }
                let mut values = vec![LiNo::Ref(id)];
                values.extend(children);
                LiNo::Link { id: None, values }
            }
        }
    } else if link.id.is_none() && link.nested.is_none() && link.values.len() == 1 {
        match current {
            LiNo::Link { id: None, values } => values.into_iter().next().unwrap(),
            value => value,
        }
    } else {
        current
    }
}

/// The document as the parser reads it: with the comments blanked out when the
/// configuration asks for comments, and untouched when it does not.
///
/// Blanking keeps every byte of the document where it was, so a position the
/// parser reports is a position in the document the caller passed in.
fn prepare<'a>(document: &'a str, config: &ParserConfig) -> Cow<'a, str> {
    if config.comments {
        Cow::Owned(strip_comments(document))
    } else {
        Cow::Borrowed(document)
    }
}

/// Reads a document, with comments.
///
/// A `#` written where a line or a token starts opens a comment that runs to
/// the end of the line; [`parse_lino_with_config`] reads a document without
/// them.
///
/// This is the AST mode: the links hold what each reference means, not how it
/// was written. [`parse_lino_to_syntax_links`] reads the same links with the
/// text of every ID, and [`parse_lino_to_cst`] reads every character of the
/// document.
///
/// # Examples
/// ```
/// use links_notation::parse_lino;
///
/// let parsed = parse_lino("# what the gate checks\nci_gate: rust\n").unwrap();
/// assert_eq!(format!("{}", parsed), "((ci_gate: rust))");
/// ```
pub fn parse_lino(document: &str) -> Result<LiNo<String>, ParseError> {
    parse_lino_with_config(document, &ParserConfig::default())
}

/// Reads a document the way `config` says to.
///
/// # Examples
/// ```
/// use links_notation::{parse_lino_with_config, ParserConfig};
///
/// let document = "# a: b";
/// assert_eq!(
///     format!("{}", parse_lino_with_config(document, &ParserConfig::new()).unwrap()),
///     "()"
/// );
/// assert!(parse_lino_with_config(document, &ParserConfig::without_comments()).is_err());
/// ```
pub fn parse_lino_with_config(
    document: &str,
    config: &ParserConfig,
) -> Result<LiNo<String>, ParseError> {
    // Handle empty or whitespace-only input by returning empty result
    if document.trim_matches(parser::is_whitespace_char).is_empty() {
        return Ok(LiNo::Link {
            id: None,
            values: vec![],
        });
    }

    let prepared = prepare(document, config);
    match parser::parse_document_with_max_depth(&prepared, config.max_depth) {
        Ok(links) => {
            if links.is_empty() {
                Ok(LiNo::Link {
                    id: None,
                    values: vec![],
                })
            } else {
                // Flatten the indented structure according to Lino spec
                let flattened = flatten_links(&links, &plain_id);
                Ok(LiNo::Link {
                    id: None,
                    values: flattened,
                })
            }
        }
        Err(failure) => Err(parse_error(document, failure)),
    }
}

/// Reads a document into a collection of links, with comments.
///
/// This is the AST mode: `1` and `'1'` are both read as the reference `1`.
/// [`parse_lino_to_syntax_links`] reads the same links and records how each ID
/// was written, and [`parse_lino_to_cst`] keeps every character of the document.
///
/// # Examples
/// ```
/// use links_notation::{format_links, parse_lino_to_links};
///
/// let links = parse_lino_to_links("(t 1 '1')").unwrap();
/// assert_eq!(format_links(&links), "(t 1 1)");
/// ```
pub fn parse_lino_to_links(document: &str) -> Result<Vec<LiNo<String>>, ParseError> {
    parse_lino_to_links_with_config(document, &ParserConfig::default())
}

/// Reads a document into a collection of links the way `config` says to.
///
/// # Examples
/// ```
/// use links_notation::{parse_lino_to_links_with_config, ParserConfig};
///
/// let links = parse_lino_to_links_with_config("a: b # why", &ParserConfig::new()).unwrap();
/// assert_eq!(links.len(), 1);
/// assert_eq!(format!("{}", links[0]), "(a: b)");
/// ```
pub fn parse_lino_to_links_with_config(
    document: &str,
    config: &ParserConfig,
) -> Result<Vec<LiNo<String>>, ParseError> {
    read_links(document, config, &plain_id)
}

/// Reads a document into a collection of links whose references record how
/// they were written.
///
/// The links are the ones [`parse_lino_to_links`] reads, with every ID a
/// [`SyntaxReference`]: its [`value`](SyntaxReference::value) is the ID
/// `parse_lino_to_links` reads and its [`raw`](SyntaxReference::raw) is the ID
/// exactly as written, so `(t 1 '1')` still holds two equal references `1` but
/// the second one knows it was quoted. A link made by combining the lines of an
/// indented document has no ID, so it has no raw text either.
///
/// [`parse_lino_to_links`] and [`parse_lino`] are the AST mode: they read the
/// same links without the syntax. Turn one into the other with
/// [`LiNo::into_values`] or `From`. [`StreamParser::syntax`] reads the same
/// links from a stream.
///
/// # Examples
/// ```
/// use links_notation::{LiNo, format_links, parse_lino_to_links, parse_lino_to_syntax_links};
///
/// let links = parse_lino_to_syntax_links("(\"a\": 'b' c)").unwrap();
/// let LiNo::Link { id: Some(id), values } = &links[0] else { unreachable!() };
/// assert_eq!(id.value, "a");
/// assert_eq!(id.raw.as_deref(), Some("\"a\""));
/// assert_eq!(id.quote(), Some('"'));
/// assert_eq!(values[0].raw_id(), Some("'b'"));
/// assert_eq!(values[1].quote(), None);
///
/// // Formatting and the plain links are exactly what the AST mode reads.
/// assert_eq!(format!("{}", links[0]), "(a: b c)");
/// let plain: Vec<LiNo<String>> = links.into_iter().map(LiNo::into_values).collect();
/// assert_eq!(plain, parse_lino_to_links("(\"a\": 'b' c)").unwrap());
/// assert_eq!(format_links(&plain), "(a: b c)");
/// ```
pub fn parse_lino_to_syntax_links(
    document: &str,
) -> Result<Vec<LiNo<SyntaxReference>>, ParseError> {
    parse_lino_to_syntax_links_with_config(document, &ParserConfig::default())
}

/// Reads a document the way `config` says to into a collection of links whose
/// references record how they were written; see [`parse_lino_to_syntax_links`].
///
/// # Examples
/// ```
/// use links_notation::{LiNo, ParserConfig, parse_lino_to_syntax_links_with_config};
///
/// let config = ParserConfig::without_comments();
/// let links = parse_lino_to_syntax_links_with_config("a #b", &config).unwrap();
/// let LiNo::Link { values, .. } = &links[0] else { unreachable!() };
/// assert_eq!(values[1].raw_id(), Some("#b"));
/// ```
pub fn parse_lino_to_syntax_links_with_config(
    document: &str,
    config: &ParserConfig,
) -> Result<Vec<LiNo<SyntaxReference>>, ParseError> {
    read_links(document, config, &|link| syntax_id(link, document))
}

/// Reads a document into a collection of links, giving each link the ID `id`
/// reads from the parsed link.
fn read_links<T: Clone, F: IdReader<T>>(
    document: &str,
    config: &ParserConfig,
    id: &F,
) -> Result<Vec<LiNo<T>>, ParseError> {
    // Handle empty or whitespace-only input by returning empty collection
    if document.trim_matches(parser::is_whitespace_char).is_empty() {
        return Ok(vec![]);
    }

    let prepared = prepare(document, config);
    match parser::parse_document_with_max_depth(&prepared, config.max_depth) {
        Ok(links) => {
            if links.is_empty() {
                Ok(vec![])
            } else {
                // Flatten the indented structure according to Lino spec
                let flattened = flatten_links(&links, id);
                Ok(flattened)
            }
        }
        Err(failure) => Err(parse_error(document, failure)),
    }
}

/// Parses a document only to find out whether it parses, returning the document
/// as the parser read it: with its comments blanked when `config` asks for
/// comments.
pub(crate) fn check_document<'a>(
    document: &'a str,
    config: &ParserConfig,
) -> Result<Cow<'a, str>, ParseError> {
    let prepared = prepare(document, config);
    if document.trim_matches(parser::is_whitespace_char).is_empty() {
        return Ok(prepared);
    }
    match parser::parse_document_with_max_depth(&prepared, config.max_depth) {
        Ok(_) => Ok(prepared),
        Err(failure) => Err(parse_error(document, failure)),
    }
}

/// Formats a collection of LiNo links as a multi-line string.
/// Each link is formatted on a separate line.
pub fn format_links(links: &[LiNo<String>]) -> String {
    links
        .iter()
        .map(|link| format!("{}", link))
        .collect::<Vec<_>>()
        .join("\n")
}

/// Formats a collection of LiNo links as a multi-line string using FormatConfig.
/// Supports all formatting options including consecutive link grouping.
///
/// # Arguments
/// * `links` - The collection of links to format
/// * `config` - The FormatConfig to use for formatting
///
/// # Returns
/// Formatted string in Lino notation
pub fn format_links_with_config(links: &[LiNo<String>], config: &FormatConfig) -> String {
    if links.is_empty() {
        return String::new();
    }

    // Apply consecutive link grouping if enabled
    let links_to_format = if config.group_consecutive {
        group_consecutive_links(links)
    } else {
        links.to_vec()
    };

    links_to_format
        .iter()
        .map(|link| link.format_with_config(config))
        .collect::<Vec<_>>()
        .join("\n")
}

/// Groups consecutive links with the same ID.
///
/// For example:
/// ```text
/// SetA a
/// SetA b
/// SetA c
/// ```
/// Becomes:
/// ```text
/// SetA
///   a
///   b
///   c
/// ```
fn group_consecutive_links(links: &[LiNo<String>]) -> Vec<LiNo<String>> {
    if links.is_empty() {
        return vec![];
    }

    let mut grouped = vec![];
    let mut i = 0;

    while i < links.len() {
        let current = &links[i];

        // Look ahead for consecutive links with same ID
        if let LiNo::Link {
            id: Some(current_id),
            values: current_values,
        } = current
        {
            if !current_values.is_empty() {
                // Collect all values with same ID
                let mut same_id_values = current_values.clone();
                let mut j = i + 1;

                while j < links.len() {
                    if let LiNo::Link {
                        id: Some(next_id),
                        values: next_values,
                    } = &links[j]
                    {
                        if next_id == current_id && !next_values.is_empty() {
                            same_id_values.extend(next_values.clone());
                            j += 1;
                        } else {
                            break;
                        }
                    } else {
                        break;
                    }
                }

                // If we found consecutive links, create grouped link
                if j > i + 1 {
                    grouped.push(LiNo::Link {
                        id: Some(current_id.clone()),
                        values: same_id_values,
                    });
                    i = j;
                    continue;
                }
            }
        }

        grouped.push(current.clone());
        i += 1;
    }

    grouped
}

/// Escape a reference string by adding quotes if necessary.
fn escape_reference(reference: &str) -> String {
    reference_literal::format_reference(reference)
}

/// Check if a string needs to be wrapped in parentheses.
fn needs_parentheses(s: &str) -> bool {
    s.contains(' ') || s.contains(':') || s.contains('(') || s.contains(')')
}

/// Format a value within a link.
fn format_value<T: ToString>(value: &LiNo<T>) -> String {
    match value {
        LiNo::Ref(r) => escape_reference(&r.to_string()),
        LiNo::Link { id, values } => {
            // Simple link with just an ID - don't wrap in extra parentheses
            if values.is_empty() {
                if let Some(id_val) = id {
                    return escape_reference(&id_val.to_string());
                }
                return String::new();
            }
            // Complex value - format with parentheses
            format!("{}", value)
        }
    }
}

// Tuple conversion implementations for ergonomic link creation
// These implementations allow creating links using Rust tuple syntax
//
// The macro generates From implementations for tuples of sizes 2-12.
// For each size, it generates 4 types of conversions:
// 1. All &str - first element becomes ID, rest become values
// 2. All String - first element becomes ID, rest become values
// 3. &str ID with LiNo values - first element becomes ID, LiNo elements become values
// 4. All LiNo - creates anonymous link (no ID) with all elements as values

/// Macro to implement From trait for tuples converting to LiNo<String>.
///
/// This macro generates four From implementations for each tuple size:
/// - `(&str, &str, ...)` - First element becomes ID, rest become string values
/// - `(String, String, ...)` - First element becomes ID, rest become string values
/// - `(&str, LiNo<String>, ...)` - First element becomes ID, LiNo elements become values
/// - `(LiNo<String>, LiNo<String>, ...)` - Creates anonymous link with all elements as values
///
/// # Examples
/// ```
/// use links_notation::LiNo;
///
/// // 2-tuple: ("id", "value") -> (id: value)
/// let link: LiNo<String> = ("papa", "mama").into();
/// assert_eq!(format!("{}", link), "(papa: mama)");
///
/// // 3-tuple: ("id", "v1", "v2") -> (id: v1 v2)
/// let link: LiNo<String> = ("parent", "child1", "child2").into();
/// assert_eq!(format!("{}", link), "(parent: child1 child2)");
///
/// // Anonymous link from all LiNo elements
/// let a = LiNo::Ref("a".to_string());
/// let b = LiNo::Ref("b".to_string());
/// let link: LiNo<String> = (a, b).into();
/// assert_eq!(format!("{}", link), "(a b)");
/// ```
macro_rules! impl_tuple_from {
    // Implementation for 2-tuples
    (@str_tuple 2, $t0:tt, $t1:tt) => {
        impl From<(&str, &str)> for LiNo<String> {
            fn from(tuple: (&str, &str)) -> Self {
                LiNo::Link {
                    id: Some(tuple.$t0.to_string()),
                    values: vec![LiNo::Ref(tuple.$t1.to_string())],
                }
            }
        }
    };
    (@string_tuple 2, $t0:tt, $t1:tt) => {
        impl From<(String, String)> for LiNo<String> {
            fn from(tuple: (String, String)) -> Self {
                LiNo::Link {
                    id: Some(tuple.$t0),
                    values: vec![LiNo::Ref(tuple.$t1)],
                }
            }
        }
    };
    (@str_lino_tuple 2, $t0:tt, $t1:tt) => {
        impl From<(&str, LiNo<String>)> for LiNo<String> {
            fn from(tuple: (&str, LiNo<String>)) -> Self {
                LiNo::Link {
                    id: Some(tuple.$t0.to_string()),
                    values: vec![tuple.$t1],
                }
            }
        }
    };
    (@lino_tuple 2, $t0:tt, $t1:tt) => {
        impl From<(LiNo<String>, LiNo<String>)> for LiNo<String> {
            fn from(tuple: (LiNo<String>, LiNo<String>)) -> Self {
                LiNo::Link {
                    id: None,
                    values: vec![tuple.$t0, tuple.$t1],
                }
            }
        }
    };

    // Implementation for 3-tuples
    (@str_tuple 3, $t0:tt, $t1:tt, $t2:tt) => {
        impl From<(&str, &str, &str)> for LiNo<String> {
            fn from(tuple: (&str, &str, &str)) -> Self {
                LiNo::Link {
                    id: Some(tuple.$t0.to_string()),
                    values: vec![LiNo::Ref(tuple.$t1.to_string()), LiNo::Ref(tuple.$t2.to_string())],
                }
            }
        }
    };
    (@string_tuple 3, $t0:tt, $t1:tt, $t2:tt) => {
        impl From<(String, String, String)> for LiNo<String> {
            fn from(tuple: (String, String, String)) -> Self {
                LiNo::Link {
                    id: Some(tuple.$t0),
                    values: vec![LiNo::Ref(tuple.$t1), LiNo::Ref(tuple.$t2)],
                }
            }
        }
    };
    (@str_lino_tuple 3, $t0:tt, $t1:tt, $t2:tt) => {
        impl From<(&str, LiNo<String>, LiNo<String>)> for LiNo<String> {
            fn from(tuple: (&str, LiNo<String>, LiNo<String>)) -> Self {
                LiNo::Link {
                    id: Some(tuple.$t0.to_string()),
                    values: vec![tuple.$t1, tuple.$t2],
                }
            }
        }
    };
    (@lino_tuple 3, $t0:tt, $t1:tt, $t2:tt) => {
        impl From<(LiNo<String>, LiNo<String>, LiNo<String>)> for LiNo<String> {
            fn from(tuple: (LiNo<String>, LiNo<String>, LiNo<String>)) -> Self {
                LiNo::Link {
                    id: None,
                    values: vec![tuple.$t0, tuple.$t1, tuple.$t2],
                }
            }
        }
    };

    // Implementation for 4-tuples
    (@str_tuple 4, $t0:tt, $t1:tt, $t2:tt, $t3:tt) => {
        impl From<(&str, &str, &str, &str)> for LiNo<String> {
            fn from(tuple: (&str, &str, &str, &str)) -> Self {
                LiNo::Link {
                    id: Some(tuple.$t0.to_string()),
                    values: vec![
                        LiNo::Ref(tuple.$t1.to_string()),
                        LiNo::Ref(tuple.$t2.to_string()),
                        LiNo::Ref(tuple.$t3.to_string()),
                    ],
                }
            }
        }
    };
    (@string_tuple 4, $t0:tt, $t1:tt, $t2:tt, $t3:tt) => {
        impl From<(String, String, String, String)> for LiNo<String> {
            fn from(tuple: (String, String, String, String)) -> Self {
                LiNo::Link {
                    id: Some(tuple.$t0),
                    values: vec![LiNo::Ref(tuple.$t1), LiNo::Ref(tuple.$t2), LiNo::Ref(tuple.$t3)],
                }
            }
        }
    };
    (@str_lino_tuple 4, $t0:tt, $t1:tt, $t2:tt, $t3:tt) => {
        impl From<(&str, LiNo<String>, LiNo<String>, LiNo<String>)> for LiNo<String> {
            fn from(tuple: (&str, LiNo<String>, LiNo<String>, LiNo<String>)) -> Self {
                LiNo::Link {
                    id: Some(tuple.$t0.to_string()),
                    values: vec![tuple.$t1, tuple.$t2, tuple.$t3],
                }
            }
        }
    };
    (@lino_tuple 4, $t0:tt, $t1:tt, $t2:tt, $t3:tt) => {
        impl From<(LiNo<String>, LiNo<String>, LiNo<String>, LiNo<String>)> for LiNo<String> {
            fn from(tuple: (LiNo<String>, LiNo<String>, LiNo<String>, LiNo<String>)) -> Self {
                LiNo::Link {
                    id: None,
                    values: vec![tuple.$t0, tuple.$t1, tuple.$t2, tuple.$t3],
                }
            }
        }
    };

    // Implementation for 5-tuples
    (@str_tuple 5, $t0:tt, $t1:tt, $t2:tt, $t3:tt, $t4:tt) => {
        impl From<(&str, &str, &str, &str, &str)> for LiNo<String> {
            fn from(tuple: (&str, &str, &str, &str, &str)) -> Self {
                LiNo::Link {
                    id: Some(tuple.$t0.to_string()),
                    values: vec![
                        LiNo::Ref(tuple.$t1.to_string()),
                        LiNo::Ref(tuple.$t2.to_string()),
                        LiNo::Ref(tuple.$t3.to_string()),
                        LiNo::Ref(tuple.$t4.to_string()),
                    ],
                }
            }
        }
    };
    (@string_tuple 5, $t0:tt, $t1:tt, $t2:tt, $t3:tt, $t4:tt) => {
        impl From<(String, String, String, String, String)> for LiNo<String> {
            fn from(tuple: (String, String, String, String, String)) -> Self {
                LiNo::Link {
                    id: Some(tuple.$t0),
                    values: vec![
                        LiNo::Ref(tuple.$t1),
                        LiNo::Ref(tuple.$t2),
                        LiNo::Ref(tuple.$t3),
                        LiNo::Ref(tuple.$t4),
                    ],
                }
            }
        }
    };
    (@str_lino_tuple 5, $t0:tt, $t1:tt, $t2:tt, $t3:tt, $t4:tt) => {
        impl From<(&str, LiNo<String>, LiNo<String>, LiNo<String>, LiNo<String>)> for LiNo<String> {
            fn from(tuple: (&str, LiNo<String>, LiNo<String>, LiNo<String>, LiNo<String>)) -> Self {
                LiNo::Link {
                    id: Some(tuple.$t0.to_string()),
                    values: vec![tuple.$t1, tuple.$t2, tuple.$t3, tuple.$t4],
                }
            }
        }
    };
    (@lino_tuple 5, $t0:tt, $t1:tt, $t2:tt, $t3:tt, $t4:tt) => {
        impl From<(LiNo<String>, LiNo<String>, LiNo<String>, LiNo<String>, LiNo<String>)> for LiNo<String> {
            fn from(tuple: (LiNo<String>, LiNo<String>, LiNo<String>, LiNo<String>, LiNo<String>)) -> Self {
                LiNo::Link {
                    id: None,
                    values: vec![tuple.$t0, tuple.$t1, tuple.$t2, tuple.$t3, tuple.$t4],
                }
            }
        }
    };

    // Implementation for 6-tuples
    (@str_tuple 6, $t0:tt, $t1:tt, $t2:tt, $t3:tt, $t4:tt, $t5:tt) => {
        impl From<(&str, &str, &str, &str, &str, &str)> for LiNo<String> {
            fn from(tuple: (&str, &str, &str, &str, &str, &str)) -> Self {
                LiNo::Link {
                    id: Some(tuple.$t0.to_string()),
                    values: vec![
                        LiNo::Ref(tuple.$t1.to_string()),
                        LiNo::Ref(tuple.$t2.to_string()),
                        LiNo::Ref(tuple.$t3.to_string()),
                        LiNo::Ref(tuple.$t4.to_string()),
                        LiNo::Ref(tuple.$t5.to_string()),
                    ],
                }
            }
        }
    };
    (@string_tuple 6, $t0:tt, $t1:tt, $t2:tt, $t3:tt, $t4:tt, $t5:tt) => {
        impl From<(String, String, String, String, String, String)> for LiNo<String> {
            fn from(tuple: (String, String, String, String, String, String)) -> Self {
                LiNo::Link {
                    id: Some(tuple.$t0),
                    values: vec![
                        LiNo::Ref(tuple.$t1),
                        LiNo::Ref(tuple.$t2),
                        LiNo::Ref(tuple.$t3),
                        LiNo::Ref(tuple.$t4),
                        LiNo::Ref(tuple.$t5),
                    ],
                }
            }
        }
    };
    (@str_lino_tuple 6, $t0:tt, $t1:tt, $t2:tt, $t3:tt, $t4:tt, $t5:tt) => {
        impl From<(&str, LiNo<String>, LiNo<String>, LiNo<String>, LiNo<String>, LiNo<String>)> for LiNo<String> {
            fn from(tuple: (&str, LiNo<String>, LiNo<String>, LiNo<String>, LiNo<String>, LiNo<String>)) -> Self {
                LiNo::Link {
                    id: Some(tuple.$t0.to_string()),
                    values: vec![tuple.$t1, tuple.$t2, tuple.$t3, tuple.$t4, tuple.$t5],
                }
            }
        }
    };
    (@lino_tuple 6, $t0:tt, $t1:tt, $t2:tt, $t3:tt, $t4:tt, $t5:tt) => {
        impl From<(LiNo<String>, LiNo<String>, LiNo<String>, LiNo<String>, LiNo<String>, LiNo<String>)> for LiNo<String> {
            fn from(tuple: (LiNo<String>, LiNo<String>, LiNo<String>, LiNo<String>, LiNo<String>, LiNo<String>)) -> Self {
                LiNo::Link {
                    id: None,
                    values: vec![tuple.$t0, tuple.$t1, tuple.$t2, tuple.$t3, tuple.$t4, tuple.$t5],
                }
            }
        }
    };

    // Implementation for 7-tuples
    (@str_tuple 7, $t0:tt, $t1:tt, $t2:tt, $t3:tt, $t4:tt, $t5:tt, $t6:tt) => {
        impl From<(&str, &str, &str, &str, &str, &str, &str)> for LiNo<String> {
            fn from(tuple: (&str, &str, &str, &str, &str, &str, &str)) -> Self {
                LiNo::Link {
                    id: Some(tuple.$t0.to_string()),
                    values: vec![
                        LiNo::Ref(tuple.$t1.to_string()),
                        LiNo::Ref(tuple.$t2.to_string()),
                        LiNo::Ref(tuple.$t3.to_string()),
                        LiNo::Ref(tuple.$t4.to_string()),
                        LiNo::Ref(tuple.$t5.to_string()),
                        LiNo::Ref(tuple.$t6.to_string()),
                    ],
                }
            }
        }
    };
    (@string_tuple 7, $t0:tt, $t1:tt, $t2:tt, $t3:tt, $t4:tt, $t5:tt, $t6:tt) => {
        impl From<(String, String, String, String, String, String, String)> for LiNo<String> {
            fn from(tuple: (String, String, String, String, String, String, String)) -> Self {
                LiNo::Link {
                    id: Some(tuple.$t0),
                    values: vec![
                        LiNo::Ref(tuple.$t1),
                        LiNo::Ref(tuple.$t2),
                        LiNo::Ref(tuple.$t3),
                        LiNo::Ref(tuple.$t4),
                        LiNo::Ref(tuple.$t5),
                        LiNo::Ref(tuple.$t6),
                    ],
                }
            }
        }
    };
    (@str_lino_tuple 7, $t0:tt, $t1:tt, $t2:tt, $t3:tt, $t4:tt, $t5:tt, $t6:tt) => {
        impl From<(&str, LiNo<String>, LiNo<String>, LiNo<String>, LiNo<String>, LiNo<String>, LiNo<String>)> for LiNo<String> {
            fn from(tuple: (&str, LiNo<String>, LiNo<String>, LiNo<String>, LiNo<String>, LiNo<String>, LiNo<String>)) -> Self {
                LiNo::Link {
                    id: Some(tuple.$t0.to_string()),
                    values: vec![tuple.$t1, tuple.$t2, tuple.$t3, tuple.$t4, tuple.$t5, tuple.$t6],
                }
            }
        }
    };
    (@lino_tuple 7, $t0:tt, $t1:tt, $t2:tt, $t3:tt, $t4:tt, $t5:tt, $t6:tt) => {
        impl From<(LiNo<String>, LiNo<String>, LiNo<String>, LiNo<String>, LiNo<String>, LiNo<String>, LiNo<String>)> for LiNo<String> {
            fn from(tuple: (LiNo<String>, LiNo<String>, LiNo<String>, LiNo<String>, LiNo<String>, LiNo<String>, LiNo<String>)) -> Self {
                LiNo::Link {
                    id: None,
                    values: vec![tuple.$t0, tuple.$t1, tuple.$t2, tuple.$t3, tuple.$t4, tuple.$t5, tuple.$t6],
                }
            }
        }
    };

    // Implementation for 8-tuples
    (@str_tuple 8, $t0:tt, $t1:tt, $t2:tt, $t3:tt, $t4:tt, $t5:tt, $t6:tt, $t7:tt) => {
        impl From<(&str, &str, &str, &str, &str, &str, &str, &str)> for LiNo<String> {
            fn from(tuple: (&str, &str, &str, &str, &str, &str, &str, &str)) -> Self {
                LiNo::Link {
                    id: Some(tuple.$t0.to_string()),
                    values: vec![
                        LiNo::Ref(tuple.$t1.to_string()),
                        LiNo::Ref(tuple.$t2.to_string()),
                        LiNo::Ref(tuple.$t3.to_string()),
                        LiNo::Ref(tuple.$t4.to_string()),
                        LiNo::Ref(tuple.$t5.to_string()),
                        LiNo::Ref(tuple.$t6.to_string()),
                        LiNo::Ref(tuple.$t7.to_string()),
                    ],
                }
            }
        }
    };
    (@string_tuple 8, $t0:tt, $t1:tt, $t2:tt, $t3:tt, $t4:tt, $t5:tt, $t6:tt, $t7:tt) => {
        impl From<(String, String, String, String, String, String, String, String)> for LiNo<String> {
            fn from(tuple: (String, String, String, String, String, String, String, String)) -> Self {
                LiNo::Link {
                    id: Some(tuple.$t0),
                    values: vec![
                        LiNo::Ref(tuple.$t1),
                        LiNo::Ref(tuple.$t2),
                        LiNo::Ref(tuple.$t3),
                        LiNo::Ref(tuple.$t4),
                        LiNo::Ref(tuple.$t5),
                        LiNo::Ref(tuple.$t6),
                        LiNo::Ref(tuple.$t7),
                    ],
                }
            }
        }
    };
    (@str_lino_tuple 8, $t0:tt, $t1:tt, $t2:tt, $t3:tt, $t4:tt, $t5:tt, $t6:tt, $t7:tt) => {
        impl From<(&str, LiNo<String>, LiNo<String>, LiNo<String>, LiNo<String>, LiNo<String>, LiNo<String>, LiNo<String>)> for LiNo<String> {
            fn from(tuple: (&str, LiNo<String>, LiNo<String>, LiNo<String>, LiNo<String>, LiNo<String>, LiNo<String>, LiNo<String>)) -> Self {
                LiNo::Link {
                    id: Some(tuple.$t0.to_string()),
                    values: vec![tuple.$t1, tuple.$t2, tuple.$t3, tuple.$t4, tuple.$t5, tuple.$t6, tuple.$t7],
                }
            }
        }
    };
    (@lino_tuple 8, $t0:tt, $t1:tt, $t2:tt, $t3:tt, $t4:tt, $t5:tt, $t6:tt, $t7:tt) => {
        impl From<(LiNo<String>, LiNo<String>, LiNo<String>, LiNo<String>, LiNo<String>, LiNo<String>, LiNo<String>, LiNo<String>)> for LiNo<String> {
            fn from(tuple: (LiNo<String>, LiNo<String>, LiNo<String>, LiNo<String>, LiNo<String>, LiNo<String>, LiNo<String>, LiNo<String>)) -> Self {
                LiNo::Link {
                    id: None,
                    values: vec![tuple.$t0, tuple.$t1, tuple.$t2, tuple.$t3, tuple.$t4, tuple.$t5, tuple.$t6, tuple.$t7],
                }
            }
        }
    };

    // Implementation for 9-tuples
    (@str_tuple 9, $t0:tt, $t1:tt, $t2:tt, $t3:tt, $t4:tt, $t5:tt, $t6:tt, $t7:tt, $t8:tt) => {
        impl From<(&str, &str, &str, &str, &str, &str, &str, &str, &str)> for LiNo<String> {
            fn from(tuple: (&str, &str, &str, &str, &str, &str, &str, &str, &str)) -> Self {
                LiNo::Link {
                    id: Some(tuple.$t0.to_string()),
                    values: vec![
                        LiNo::Ref(tuple.$t1.to_string()),
                        LiNo::Ref(tuple.$t2.to_string()),
                        LiNo::Ref(tuple.$t3.to_string()),
                        LiNo::Ref(tuple.$t4.to_string()),
                        LiNo::Ref(tuple.$t5.to_string()),
                        LiNo::Ref(tuple.$t6.to_string()),
                        LiNo::Ref(tuple.$t7.to_string()),
                        LiNo::Ref(tuple.$t8.to_string()),
                    ],
                }
            }
        }
    };
    (@string_tuple 9, $t0:tt, $t1:tt, $t2:tt, $t3:tt, $t4:tt, $t5:tt, $t6:tt, $t7:tt, $t8:tt) => {
        impl From<(String, String, String, String, String, String, String, String, String)> for LiNo<String> {
            fn from(tuple: (String, String, String, String, String, String, String, String, String)) -> Self {
                LiNo::Link {
                    id: Some(tuple.$t0),
                    values: vec![
                        LiNo::Ref(tuple.$t1),
                        LiNo::Ref(tuple.$t2),
                        LiNo::Ref(tuple.$t3),
                        LiNo::Ref(tuple.$t4),
                        LiNo::Ref(tuple.$t5),
                        LiNo::Ref(tuple.$t6),
                        LiNo::Ref(tuple.$t7),
                        LiNo::Ref(tuple.$t8),
                    ],
                }
            }
        }
    };
    (@str_lino_tuple 9, $t0:tt, $t1:tt, $t2:tt, $t3:tt, $t4:tt, $t5:tt, $t6:tt, $t7:tt, $t8:tt) => {
        impl From<(&str, LiNo<String>, LiNo<String>, LiNo<String>, LiNo<String>, LiNo<String>, LiNo<String>, LiNo<String>, LiNo<String>)> for LiNo<String> {
            fn from(tuple: (&str, LiNo<String>, LiNo<String>, LiNo<String>, LiNo<String>, LiNo<String>, LiNo<String>, LiNo<String>, LiNo<String>)) -> Self {
                LiNo::Link {
                    id: Some(tuple.$t0.to_string()),
                    values: vec![tuple.$t1, tuple.$t2, tuple.$t3, tuple.$t4, tuple.$t5, tuple.$t6, tuple.$t7, tuple.$t8],
                }
            }
        }
    };
    (@lino_tuple 9, $t0:tt, $t1:tt, $t2:tt, $t3:tt, $t4:tt, $t5:tt, $t6:tt, $t7:tt, $t8:tt) => {
        impl From<(LiNo<String>, LiNo<String>, LiNo<String>, LiNo<String>, LiNo<String>, LiNo<String>, LiNo<String>, LiNo<String>, LiNo<String>)> for LiNo<String> {
            fn from(tuple: (LiNo<String>, LiNo<String>, LiNo<String>, LiNo<String>, LiNo<String>, LiNo<String>, LiNo<String>, LiNo<String>, LiNo<String>)) -> Self {
                LiNo::Link {
                    id: None,
                    values: vec![tuple.$t0, tuple.$t1, tuple.$t2, tuple.$t3, tuple.$t4, tuple.$t5, tuple.$t6, tuple.$t7, tuple.$t8],
                }
            }
        }
    };

    // Implementation for 10-tuples
    (@str_tuple 10, $t0:tt, $t1:tt, $t2:tt, $t3:tt, $t4:tt, $t5:tt, $t6:tt, $t7:tt, $t8:tt, $t9:tt) => {
        impl From<(&str, &str, &str, &str, &str, &str, &str, &str, &str, &str)> for LiNo<String> {
            fn from(tuple: (&str, &str, &str, &str, &str, &str, &str, &str, &str, &str)) -> Self {
                LiNo::Link {
                    id: Some(tuple.$t0.to_string()),
                    values: vec![
                        LiNo::Ref(tuple.$t1.to_string()),
                        LiNo::Ref(tuple.$t2.to_string()),
                        LiNo::Ref(tuple.$t3.to_string()),
                        LiNo::Ref(tuple.$t4.to_string()),
                        LiNo::Ref(tuple.$t5.to_string()),
                        LiNo::Ref(tuple.$t6.to_string()),
                        LiNo::Ref(tuple.$t7.to_string()),
                        LiNo::Ref(tuple.$t8.to_string()),
                        LiNo::Ref(tuple.$t9.to_string()),
                    ],
                }
            }
        }
    };
    (@string_tuple 10, $t0:tt, $t1:tt, $t2:tt, $t3:tt, $t4:tt, $t5:tt, $t6:tt, $t7:tt, $t8:tt, $t9:tt) => {
        impl From<(String, String, String, String, String, String, String, String, String, String)> for LiNo<String> {
            fn from(tuple: (String, String, String, String, String, String, String, String, String, String)) -> Self {
                LiNo::Link {
                    id: Some(tuple.$t0),
                    values: vec![
                        LiNo::Ref(tuple.$t1),
                        LiNo::Ref(tuple.$t2),
                        LiNo::Ref(tuple.$t3),
                        LiNo::Ref(tuple.$t4),
                        LiNo::Ref(tuple.$t5),
                        LiNo::Ref(tuple.$t6),
                        LiNo::Ref(tuple.$t7),
                        LiNo::Ref(tuple.$t8),
                        LiNo::Ref(tuple.$t9),
                    ],
                }
            }
        }
    };
    (@str_lino_tuple 10, $t0:tt, $t1:tt, $t2:tt, $t3:tt, $t4:tt, $t5:tt, $t6:tt, $t7:tt, $t8:tt, $t9:tt) => {
        impl From<(&str, LiNo<String>, LiNo<String>, LiNo<String>, LiNo<String>, LiNo<String>, LiNo<String>, LiNo<String>, LiNo<String>, LiNo<String>)> for LiNo<String> {
            fn from(tuple: (&str, LiNo<String>, LiNo<String>, LiNo<String>, LiNo<String>, LiNo<String>, LiNo<String>, LiNo<String>, LiNo<String>, LiNo<String>)) -> Self {
                LiNo::Link {
                    id: Some(tuple.$t0.to_string()),
                    values: vec![tuple.$t1, tuple.$t2, tuple.$t3, tuple.$t4, tuple.$t5, tuple.$t6, tuple.$t7, tuple.$t8, tuple.$t9],
                }
            }
        }
    };
    (@lino_tuple 10, $t0:tt, $t1:tt, $t2:tt, $t3:tt, $t4:tt, $t5:tt, $t6:tt, $t7:tt, $t8:tt, $t9:tt) => {
        impl From<(LiNo<String>, LiNo<String>, LiNo<String>, LiNo<String>, LiNo<String>, LiNo<String>, LiNo<String>, LiNo<String>, LiNo<String>, LiNo<String>)> for LiNo<String> {
            fn from(tuple: (LiNo<String>, LiNo<String>, LiNo<String>, LiNo<String>, LiNo<String>, LiNo<String>, LiNo<String>, LiNo<String>, LiNo<String>, LiNo<String>)) -> Self {
                LiNo::Link {
                    id: None,
                    values: vec![tuple.$t0, tuple.$t1, tuple.$t2, tuple.$t3, tuple.$t4, tuple.$t5, tuple.$t6, tuple.$t7, tuple.$t8, tuple.$t9],
                }
            }
        }
    };

    // Implementation for 11-tuples
    (@str_tuple 11, $t0:tt, $t1:tt, $t2:tt, $t3:tt, $t4:tt, $t5:tt, $t6:tt, $t7:tt, $t8:tt, $t9:tt, $t10:tt) => {
        impl From<(&str, &str, &str, &str, &str, &str, &str, &str, &str, &str, &str)> for LiNo<String> {
            fn from(tuple: (&str, &str, &str, &str, &str, &str, &str, &str, &str, &str, &str)) -> Self {
                LiNo::Link {
                    id: Some(tuple.$t0.to_string()),
                    values: vec![
                        LiNo::Ref(tuple.$t1.to_string()),
                        LiNo::Ref(tuple.$t2.to_string()),
                        LiNo::Ref(tuple.$t3.to_string()),
                        LiNo::Ref(tuple.$t4.to_string()),
                        LiNo::Ref(tuple.$t5.to_string()),
                        LiNo::Ref(tuple.$t6.to_string()),
                        LiNo::Ref(tuple.$t7.to_string()),
                        LiNo::Ref(tuple.$t8.to_string()),
                        LiNo::Ref(tuple.$t9.to_string()),
                        LiNo::Ref(tuple.$t10.to_string()),
                    ],
                }
            }
        }
    };
    (@string_tuple 11, $t0:tt, $t1:tt, $t2:tt, $t3:tt, $t4:tt, $t5:tt, $t6:tt, $t7:tt, $t8:tt, $t9:tt, $t10:tt) => {
        impl From<(String, String, String, String, String, String, String, String, String, String, String)> for LiNo<String> {
            fn from(tuple: (String, String, String, String, String, String, String, String, String, String, String)) -> Self {
                LiNo::Link {
                    id: Some(tuple.$t0),
                    values: vec![
                        LiNo::Ref(tuple.$t1),
                        LiNo::Ref(tuple.$t2),
                        LiNo::Ref(tuple.$t3),
                        LiNo::Ref(tuple.$t4),
                        LiNo::Ref(tuple.$t5),
                        LiNo::Ref(tuple.$t6),
                        LiNo::Ref(tuple.$t7),
                        LiNo::Ref(tuple.$t8),
                        LiNo::Ref(tuple.$t9),
                        LiNo::Ref(tuple.$t10),
                    ],
                }
            }
        }
    };
    (@str_lino_tuple 11, $t0:tt, $t1:tt, $t2:tt, $t3:tt, $t4:tt, $t5:tt, $t6:tt, $t7:tt, $t8:tt, $t9:tt, $t10:tt) => {
        impl From<(&str, LiNo<String>, LiNo<String>, LiNo<String>, LiNo<String>, LiNo<String>, LiNo<String>, LiNo<String>, LiNo<String>, LiNo<String>, LiNo<String>)> for LiNo<String> {
            fn from(tuple: (&str, LiNo<String>, LiNo<String>, LiNo<String>, LiNo<String>, LiNo<String>, LiNo<String>, LiNo<String>, LiNo<String>, LiNo<String>, LiNo<String>)) -> Self {
                LiNo::Link {
                    id: Some(tuple.$t0.to_string()),
                    values: vec![tuple.$t1, tuple.$t2, tuple.$t3, tuple.$t4, tuple.$t5, tuple.$t6, tuple.$t7, tuple.$t8, tuple.$t9, tuple.$t10],
                }
            }
        }
    };
    (@lino_tuple 11, $t0:tt, $t1:tt, $t2:tt, $t3:tt, $t4:tt, $t5:tt, $t6:tt, $t7:tt, $t8:tt, $t9:tt, $t10:tt) => {
        impl From<(LiNo<String>, LiNo<String>, LiNo<String>, LiNo<String>, LiNo<String>, LiNo<String>, LiNo<String>, LiNo<String>, LiNo<String>, LiNo<String>, LiNo<String>)> for LiNo<String> {
            fn from(tuple: (LiNo<String>, LiNo<String>, LiNo<String>, LiNo<String>, LiNo<String>, LiNo<String>, LiNo<String>, LiNo<String>, LiNo<String>, LiNo<String>, LiNo<String>)) -> Self {
                LiNo::Link {
                    id: None,
                    values: vec![tuple.$t0, tuple.$t1, tuple.$t2, tuple.$t3, tuple.$t4, tuple.$t5, tuple.$t6, tuple.$t7, tuple.$t8, tuple.$t9, tuple.$t10],
                }
            }
        }
    };

    // Implementation for 12-tuples
    (@str_tuple 12, $t0:tt, $t1:tt, $t2:tt, $t3:tt, $t4:tt, $t5:tt, $t6:tt, $t7:tt, $t8:tt, $t9:tt, $t10:tt, $t11:tt) => {
        impl From<(&str, &str, &str, &str, &str, &str, &str, &str, &str, &str, &str, &str)> for LiNo<String> {
            fn from(tuple: (&str, &str, &str, &str, &str, &str, &str, &str, &str, &str, &str, &str)) -> Self {
                LiNo::Link {
                    id: Some(tuple.$t0.to_string()),
                    values: vec![
                        LiNo::Ref(tuple.$t1.to_string()),
                        LiNo::Ref(tuple.$t2.to_string()),
                        LiNo::Ref(tuple.$t3.to_string()),
                        LiNo::Ref(tuple.$t4.to_string()),
                        LiNo::Ref(tuple.$t5.to_string()),
                        LiNo::Ref(tuple.$t6.to_string()),
                        LiNo::Ref(tuple.$t7.to_string()),
                        LiNo::Ref(tuple.$t8.to_string()),
                        LiNo::Ref(tuple.$t9.to_string()),
                        LiNo::Ref(tuple.$t10.to_string()),
                        LiNo::Ref(tuple.$t11.to_string()),
                    ],
                }
            }
        }
    };
    (@string_tuple 12, $t0:tt, $t1:tt, $t2:tt, $t3:tt, $t4:tt, $t5:tt, $t6:tt, $t7:tt, $t8:tt, $t9:tt, $t10:tt, $t11:tt) => {
        impl From<(String, String, String, String, String, String, String, String, String, String, String, String)> for LiNo<String> {
            fn from(tuple: (String, String, String, String, String, String, String, String, String, String, String, String)) -> Self {
                LiNo::Link {
                    id: Some(tuple.$t0),
                    values: vec![
                        LiNo::Ref(tuple.$t1),
                        LiNo::Ref(tuple.$t2),
                        LiNo::Ref(tuple.$t3),
                        LiNo::Ref(tuple.$t4),
                        LiNo::Ref(tuple.$t5),
                        LiNo::Ref(tuple.$t6),
                        LiNo::Ref(tuple.$t7),
                        LiNo::Ref(tuple.$t8),
                        LiNo::Ref(tuple.$t9),
                        LiNo::Ref(tuple.$t10),
                        LiNo::Ref(tuple.$t11),
                    ],
                }
            }
        }
    };
    (@str_lino_tuple 12, $t0:tt, $t1:tt, $t2:tt, $t3:tt, $t4:tt, $t5:tt, $t6:tt, $t7:tt, $t8:tt, $t9:tt, $t10:tt, $t11:tt) => {
        impl From<(&str, LiNo<String>, LiNo<String>, LiNo<String>, LiNo<String>, LiNo<String>, LiNo<String>, LiNo<String>, LiNo<String>, LiNo<String>, LiNo<String>, LiNo<String>)> for LiNo<String> {
            fn from(tuple: (&str, LiNo<String>, LiNo<String>, LiNo<String>, LiNo<String>, LiNo<String>, LiNo<String>, LiNo<String>, LiNo<String>, LiNo<String>, LiNo<String>, LiNo<String>)) -> Self {
                LiNo::Link {
                    id: Some(tuple.$t0.to_string()),
                    values: vec![tuple.$t1, tuple.$t2, tuple.$t3, tuple.$t4, tuple.$t5, tuple.$t6, tuple.$t7, tuple.$t8, tuple.$t9, tuple.$t10, tuple.$t11],
                }
            }
        }
    };
    (@lino_tuple 12, $t0:tt, $t1:tt, $t2:tt, $t3:tt, $t4:tt, $t5:tt, $t6:tt, $t7:tt, $t8:tt, $t9:tt, $t10:tt, $t11:tt) => {
        impl From<(LiNo<String>, LiNo<String>, LiNo<String>, LiNo<String>, LiNo<String>, LiNo<String>, LiNo<String>, LiNo<String>, LiNo<String>, LiNo<String>, LiNo<String>, LiNo<String>)> for LiNo<String> {
            fn from(tuple: (LiNo<String>, LiNo<String>, LiNo<String>, LiNo<String>, LiNo<String>, LiNo<String>, LiNo<String>, LiNo<String>, LiNo<String>, LiNo<String>, LiNo<String>, LiNo<String>)) -> Self {
                LiNo::Link {
                    id: None,
                    values: vec![tuple.$t0, tuple.$t1, tuple.$t2, tuple.$t3, tuple.$t4, tuple.$t5, tuple.$t6, tuple.$t7, tuple.$t8, tuple.$t9, tuple.$t10, tuple.$t11],
                }
            }
        }
    };

    // Entry point - generates all four types for a given tuple size
    (2) => {
        impl_tuple_from!(@str_tuple 2, 0, 1);
        impl_tuple_from!(@string_tuple 2, 0, 1);
        impl_tuple_from!(@str_lino_tuple 2, 0, 1);
        impl_tuple_from!(@lino_tuple 2, 0, 1);
    };
    (3) => {
        impl_tuple_from!(@str_tuple 3, 0, 1, 2);
        impl_tuple_from!(@string_tuple 3, 0, 1, 2);
        impl_tuple_from!(@str_lino_tuple 3, 0, 1, 2);
        impl_tuple_from!(@lino_tuple 3, 0, 1, 2);
    };
    (4) => {
        impl_tuple_from!(@str_tuple 4, 0, 1, 2, 3);
        impl_tuple_from!(@string_tuple 4, 0, 1, 2, 3);
        impl_tuple_from!(@str_lino_tuple 4, 0, 1, 2, 3);
        impl_tuple_from!(@lino_tuple 4, 0, 1, 2, 3);
    };
    (5) => {
        impl_tuple_from!(@str_tuple 5, 0, 1, 2, 3, 4);
        impl_tuple_from!(@string_tuple 5, 0, 1, 2, 3, 4);
        impl_tuple_from!(@str_lino_tuple 5, 0, 1, 2, 3, 4);
        impl_tuple_from!(@lino_tuple 5, 0, 1, 2, 3, 4);
    };
    (6) => {
        impl_tuple_from!(@str_tuple 6, 0, 1, 2, 3, 4, 5);
        impl_tuple_from!(@string_tuple 6, 0, 1, 2, 3, 4, 5);
        impl_tuple_from!(@str_lino_tuple 6, 0, 1, 2, 3, 4, 5);
        impl_tuple_from!(@lino_tuple 6, 0, 1, 2, 3, 4, 5);
    };
    (7) => {
        impl_tuple_from!(@str_tuple 7, 0, 1, 2, 3, 4, 5, 6);
        impl_tuple_from!(@string_tuple 7, 0, 1, 2, 3, 4, 5, 6);
        impl_tuple_from!(@str_lino_tuple 7, 0, 1, 2, 3, 4, 5, 6);
        impl_tuple_from!(@lino_tuple 7, 0, 1, 2, 3, 4, 5, 6);
    };
    (8) => {
        impl_tuple_from!(@str_tuple 8, 0, 1, 2, 3, 4, 5, 6, 7);
        impl_tuple_from!(@string_tuple 8, 0, 1, 2, 3, 4, 5, 6, 7);
        impl_tuple_from!(@str_lino_tuple 8, 0, 1, 2, 3, 4, 5, 6, 7);
        impl_tuple_from!(@lino_tuple 8, 0, 1, 2, 3, 4, 5, 6, 7);
    };
    (9) => {
        impl_tuple_from!(@str_tuple 9, 0, 1, 2, 3, 4, 5, 6, 7, 8);
        impl_tuple_from!(@string_tuple 9, 0, 1, 2, 3, 4, 5, 6, 7, 8);
        impl_tuple_from!(@str_lino_tuple 9, 0, 1, 2, 3, 4, 5, 6, 7, 8);
        impl_tuple_from!(@lino_tuple 9, 0, 1, 2, 3, 4, 5, 6, 7, 8);
    };
    (10) => {
        impl_tuple_from!(@str_tuple 10, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9);
        impl_tuple_from!(@string_tuple 10, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9);
        impl_tuple_from!(@str_lino_tuple 10, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9);
        impl_tuple_from!(@lino_tuple 10, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9);
    };
    (11) => {
        impl_tuple_from!(@str_tuple 11, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10);
        impl_tuple_from!(@string_tuple 11, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10);
        impl_tuple_from!(@str_lino_tuple 11, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10);
        impl_tuple_from!(@lino_tuple 11, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10);
    };
    (12) => {
        impl_tuple_from!(@str_tuple 12, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11);
        impl_tuple_from!(@string_tuple 12, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11);
        impl_tuple_from!(@str_lino_tuple 12, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11);
        impl_tuple_from!(@lino_tuple 12, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11);
    };
}

// Generate implementations for tuples of sizes 2 through 12
// This follows the Rust standard library convention of supporting up to 12-tuples
impl_tuple_from!(2);
impl_tuple_from!(3);
impl_tuple_from!(4);
impl_tuple_from!(5);
impl_tuple_from!(6);
impl_tuple_from!(7);
impl_tuple_from!(8);
impl_tuple_from!(9);
impl_tuple_from!(10);
impl_tuple_from!(11);
impl_tuple_from!(12);

// Vec-based conversions for arbitrary-length link creation
//
// These implementations provide an escape hatch for creating links with more
// than 12 values, or when the number of values is determined at runtime.
//
// Note: Rust does not support variadic generics (as of Rust 1.92), which means
// we cannot implement `From` for tuples of arbitrary length. This is a fundamental
// limitation of Rust's type system. The Rust standard library faces the same
// limitation, which is why traits like `Debug`, `Default`, `Hash`, etc. are only
// implemented for tuples up to 12 elements.
//
// For more information, see:
// - https://github.com/rust-lang/rfcs/issues/376 (Draft RFC: variadic generics)
// - https://github.com/rust-lang/rust/issues/10124 (RFC: variadic generics)
//
// Alternative approaches for arbitrary-length links:
// 1. Use the `LiNoBuilder` API for fluent construction
// 2. Use `LiNo::new()` or `LiNo::anonymous()` with a `Vec`
// 3. Use the `From<Vec<_>>` implementations below

/// Convert a Vec of strings into an anonymous link.
///
/// # Examples
/// ```
/// use links_notation::LiNo;
///
/// // Create anonymous link from vector of any size
/// let values: Vec<&str> = (1..=20).map(|_| "val").collect();
/// let link: LiNo<String> = values.into();
/// ```
impl From<Vec<&str>> for LiNo<String> {
    fn from(values: Vec<&str>) -> Self {
        LiNo::Link {
            id: None,
            values: values
                .into_iter()
                .map(|s| LiNo::Ref(s.to_string()))
                .collect(),
        }
    }
}

/// Convert a Vec of Strings into an anonymous link.
impl From<Vec<String>> for LiNo<String> {
    fn from(values: Vec<String>) -> Self {
        LiNo::Link {
            id: None,
            values: values.into_iter().map(LiNo::Ref).collect(),
        }
    }
}

/// Convert a Vec of LiNo into an anonymous link.
impl From<Vec<LiNo<String>>> for LiNo<String> {
    fn from(values: Vec<LiNo<String>>) -> Self {
        LiNo::Link { id: None, values }
    }
}

/// Convert a tuple of (id, Vec<values>) into a named link.
///
/// # Examples
/// ```
/// use links_notation::LiNo;
///
/// // Create named link with arbitrary number of values
/// let values: Vec<&str> = vec!["v1", "v2", "v3", "v4", "v5"];
/// let link: LiNo<String> = ("myLink", values).into();
/// assert_eq!(format!("{}", link), "(myLink: v1 v2 v3 v4 v5)");
/// ```
impl From<(&str, Vec<&str>)> for LiNo<String> {
    fn from((id, values): (&str, Vec<&str>)) -> Self {
        LiNo::Link {
            id: Some(id.to_string()),
            values: values
                .into_iter()
                .map(|s| LiNo::Ref(s.to_string()))
                .collect(),
        }
    }
}

/// Convert a tuple of (id, Vec<String>) into a named link.
impl From<(String, Vec<String>)> for LiNo<String> {
    fn from((id, values): (String, Vec<String>)) -> Self {
        LiNo::Link {
            id: Some(id),
            values: values.into_iter().map(LiNo::Ref).collect(),
        }
    }
}

/// Convert a tuple of (id, Vec<LiNo>) into a named link.
impl From<(&str, Vec<LiNo<String>>)> for LiNo<String> {
    fn from((id, values): (&str, Vec<LiNo<String>>)) -> Self {
        LiNo::Link {
            id: Some(id.to_string()),
            values,
        }
    }
}

/// Convert a tuple of (String id, Vec<LiNo>) into a named link.
impl From<(String, Vec<LiNo<String>>)> for LiNo<String> {
    fn from((id, values): (String, Vec<LiNo<String>>)) -> Self {
        LiNo::Link {
            id: Some(id),
            values,
        }
    }
}