use std::fmt::Display;

struct Class;
impl Class {
    const NAME: &'static str = "class";
}

struct Tag;
impl Tag {
    const NAME: &'static str = "tag";
}

enum Node {
    Class,
    Tag,
}

struct Lemmy {
    nodes: Vec<Node>,
}

impl Nodes for Lemmy {
    fn nodes(&self) -> &Vec<Node> {
        &self.nodes
    }
}

impl<T: FromEmmy + Display> AsDoc<T> for Lemmy {
    fn as_doc(&self, s: &T::Settings) -> T {
        T::from_emmy(self, s)
    }
}

trait Nodes {
    fn nodes(&self) -> &Vec<Node>;
}

trait FromEmmy {
    type Settings;
    fn from_emmy(t: &impl Nodes, s: &Self::Settings) -> Self;
}

trait AsDoc<T: FromEmmy + Display> {
    fn as_doc(&self, s: &T::Settings) -> T;
}

struct VimDoc(String);

impl FromEmmy for VimDoc {
    type Settings = ();
    fn from_emmy(t: &impl Nodes, _: &Self::Settings) -> Self {
        for node in t.nodes() {
            let n = match node {
                Node::Class => format!("vim-{}", Class::NAME),
                Node::Tag => format!("vim-{}", Tag::NAME),
            };

            dbg!(n);
        }

        Self(String::from("vimdoc"))
    }
}

impl Display for VimDoc {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        f.write_str(self.0.as_str())
    }
}

struct HtmlDoc(String);

impl FromEmmy for HtmlDoc {
    type Settings = Option<()>;
    fn from_emmy(t: &impl Nodes, _: &Self::Settings) -> Self {
        for node in t.nodes() {
            let n = match node {
                Node::Class => format!("html-{}", Class::NAME),
                Node::Tag => format!("html-{}", Tag::NAME),
            };

            dbg!(n);
        }

        Self(String::from("htmldoc"))
    }
}

impl Display for HtmlDoc {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        f.write_str(self.0.as_str())
    }
}

fn main() {
    let lemmy = Lemmy {
        nodes: vec![Node::Class, Node::Tag],
    };

    let v = VimDoc::from_emmy(&lemmy, &());
    println!("{v}");
    let v: VimDoc = lemmy.as_doc(&());
    println!("{v}");
    let h = HtmlDoc::from_emmy(&lemmy, &None);
    println!("{h}");
    let h: HtmlDoc = lemmy.as_doc(&None);
    println!("{h}");
}

Uh oh!

Separate vimdoc generation from parser #41

Description

Pros

Metadata

Metadata

Assignees

Labels

Projects

Milestone

Relationships

Development

Issue actions

Separate `vimdoc` generation from parser #41