Struct LiNoBuilder 

pub struct LiNoBuilder { /* private fields */ }

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)");

Implementations

impl LiNoBuilder

pub fn new() -> Self

Creates a new empty LiNoBuilder.

pub fn id(self, id: &str) -> Self

Sets the ID of the link.

If called multiple times, the last value wins.

pub fn value(self, value: &str) -> Self

Adds a string value to the link (converted to a Ref).

pub fn lino(self, value: LiNo<String>) -> Self

Adds a LiNo value to the link.

pub fn values<I, S>(self, values: I) -> Self

where I: IntoIterator<Item = S>, S: AsRef<str>,

Adds multiple string values to the link.

pub fn linos<I>(self, values: I) -> Self

where I: IntoIterator<Item = LiNo<String>>,

Adds multiple LiNo values to the link.

pub fn build(self) -> LiNo<String>

Builds the final LiNo link.

Trait Implementations

impl Clone for LiNoBuilder

fn clone(&self) -> LiNoBuilder

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for LiNoBuilder

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

Formats the value using the given formatter.

impl Default for LiNoBuilder

fn default() -> LiNoBuilder

Returns the “default value” for a type.