finchie/new_manual - Change GKBSBSDY5XLAT7SDKAVFQI3PHFUHKHTJGGXZH5XWG2E45U7BSU5QC

Return `dyn Iterator` instead of `Vec` for `SupportedContent`

Allows for cleaner representation of adding a single element: Some(T) instead of Vec<T> of length 1, but Vec<T> still works. This will probably end up being replaced by a more complex representation of how a particular element impacts the Rust AST, to represent things like inline style declarations (#show blocks).

Created by finchie on November 12, 2023

GKBSBSDY5XLAT7SDKAVFQI3PHFUHKHTJGGXZH5XWG2E45U7BSU5QC

Dependencies

In channels

main

Change contents

Replacement in docs/test.typ at line 1 [3.242]

B:BD[3.242] → [2.0:66]

List:
- First
- Second
- Third
Ordered:
+ First
+ Second
+ Third

[3.242]

[2.66]

#show emph: it => {
  text(blue, it.body)
}

Replacement in docs/test.typ at line 5 [3.242]

B:BD[2.67] → [2.67:160]

#enum(
  enum.item(1)[First step],
  enum.item(5)[Fifth step],
  enum.item(10)[Tenth step]
)

[2.67]

This is _emphasized_ differently.

Replacement in crates/typser/src/lib.rs at line 10 [6.1210]

B:BD[4.11] → [5.45:145]

    token, AngleBracketedGenericArguments, ExprCall, ExprLit, ExprPath, ExprTuple, GenericArgument,

[4.11]

[5.145]

    token, AngleBracketedGenericArguments, ExprLit, ExprTuple, GenericArgument,

Deletion in crates/typser/src/lib.rs at line 241 [6.1210]

B:BD[7.10600] → [7.10600:10607]

∅:D[8.3254] → [9.3110:3113]

∅:D[7.10607] → [9.3110:3113]

B:BD[9.3110] → [9.3110:3113]

B:BD[9.3113] → [4.3953:4127]

∅:D[4.4127] → [9.3307:3316]

B:BD[9.3307] → [9.3307:3316]

B:BD[9.3316] → [5.1172:1212]

∅:D[5.1212] → [4.4163:4246]

B:BD[4.4163] → [4.4163:4246]

∅:D[9.3449] → [6.1947:1948]

∅:D[4.4246] → [6.1947:1948]

B:BD[6.1947] → [6.1947:1948]

B:BD[6.1948] → [8.3255:3366]

∅:D[8.3366] → [9.3543:3583]

B:BD[9.3543] → [9.3543:3583]

B:BD[9.3583] → [4.4247:4278]

∅:D[4.4278] → [9.3619:3767]

B:BD[9.3619] → [9.3619:3767]

B:BD[9.3767] → [5.1213:1244]

∅:D[5.1244] → [10.394:397]

B:BD[4.4305] → [10.394:397]

B:BD[10.397] → [5.1245:1354]

∅:D[5.1354] → [10.485:599]

B:BD[10.485] → [10.485:599]

B:BD[10.599] → [5.1355:1417]

    })
}
fn path_segment(segment: &str) -> PathSegment {
    PathSegment {
        ident: Ident::new(segment, proc_macro2::Span::call_site()),
        arguments: PathArguments::None,
    }
}
fn expr_path(name: &str) -> syn::Expr {
    let mut segments: Punctuated<PathSegment, token::PathSep> = Punctuated::new();
    // The path should be elements::name
    // e.g. elements::h2
    segments.push(path_segment("elements"));
    segments.push(path_segment(name));
    let expr_path = ExprPath {
        attrs: Vec::new(),
        qself: None,
        path: syn::Path {
            leading_colon: None,
            segments,
        },
    };
    syn::Expr::Path(expr_path)
}
fn xilem_html_element(name: &str, expressions: Vec<syn::Expr>) -> syn::Expr {
    syn::Expr::Call(ExprCall {
        attrs: Vec::new(),
        func: Box::new(expr_path(name)),
        paren_token: token::Paren::default(),
        args: Punctuated::from_iter(expressions.into_iter()),

Insertion in crates/typser/src/content.rs at line 1 [11.2939]
[11.2939]
[11.2940]
```
use syn::punctuated::Punctuated;
use syn::{token, ExprPath, PathSegment};
```
Replacement in crates/typser/src/content.rs at line 8 [11.2939]
B:BD[11.3054] → [12.316:365]
```
use crate::{literal_string, xilem_html_element};
```
[11.3054]
[11.3103]
```
use crate::literal_string;
```

Replacement in crates/typser/src/content.rs at line 55 [11.2939]

B:BD[11.3696] → [12.792:839]

    pub fn to_xilem(&self) -> Vec<syn::Expr> {

[11.3696]

[12.839]

    pub fn to_xilem(&self) -> Box<dyn Iterator<Item = syn::Expr> + '_> {

Replacement in crates/typser/src/content.rs at line 57 [11.2939]

B:BD[12.860] → [12.860:1059]

            SupportedContent::Sequence(sequence) => sequence
                .iter()
                .map(SupportedContent::to_xilem)
                .flatten()
                .collect::<Vec<_>>(),

[12.860]

[12.1059]

            SupportedContent::Sequence(sequence) => {
                Box::new(sequence.iter().map(SupportedContent::to_xilem).flatten())
            }

Replacement in crates/typser/src/content.rs at line 62 [11.2939]

B:BD[12.1175] → [12.1175:1244]

                vec![xilem_html_element("h1", body_text.to_xilem())]

[12.1175]

[12.1244]

                Box::new(Some(xilem_html_element("h1", body_text.to_xilem())).into_iter())

Replacement in crates/typser/src/content.rs at line 65 [11.2939]

B:BD[12.1304] → [12.1304:1379]

                vec![syn::Expr::Lit(literal_string(text.text().as_str()))]

[12.1304]

[12.1379]

                Box::new(Some(syn::Expr::Lit(literal_string(text.text().as_str()))).into_iter())

Replacement in crates/typser/src/content.rs at line 67 [11.2939]

B:BD[12.1393] → [12.1393:1634]

∅:D[12.1634] → [13.881:983]

B:BD[13.881] → [13.881:983]

B:BD[13.983] → [12.1635:2885]

B:BD[12.2885] → [2.951:1047]

            SupportedContent::Space(_space) => vec![syn::Expr::Lit(literal_string(" "))],
            SupportedContent::Table(table) => vec![xilem_html_element(
                "table",
                vec![syn::Expr::Tuple(syn::ExprTuple {
                    attrs: Vec::new(),
                    paren_token: syn::token::Paren::default(),
                    elems: syn::punctuated::Punctuated::from_iter(
                        table
                            .children()
                            .into_iter()
                            .map(|content| SupportedContent::downcast(content))
                            .map(|supported| supported.to_xilem())
                            .flatten()
                            .collect::<Vec<_>>()
                            .chunks(2) // TODO: a slightly more sophisticated layout algorithm
                            .map(|chunk| {
                                xilem_html_element(
                                    "tr",
                                    vec![syn::Expr::Tuple(syn::ExprTuple {
                                        attrs: Vec::new(),
                                        paren_token: syn::token::Paren::default(),
                                        elems: syn::punctuated::Punctuated::from_iter(
                                            chunk.into_iter().map(|item| item.to_owned()),
                                        ),
                                    })],
                                )
                            }),
                    ),
                })],
            )],
            SupportedContent::UnorderedList(list) => {
                vec![xilem_html_element(

[12.1393]

[2.1047]

            SupportedContent::Space(_space) => {
                Box::new(Some(syn::Expr::Lit(literal_string(" "))).into_iter())
            }
            SupportedContent::Table(table) => Box::new(
                Some(xilem_html_element(
                    "table",
                    Some(syn::Expr::Tuple(syn::ExprTuple {
                        attrs: Vec::new(),
                        paren_token: token::Paren::default(),
                        elems: Punctuated::from_iter(
                            table
                                .children()
                                .into_iter()
                                .map(|content| SupportedContent::downcast(content))
                                .map(|supported| supported.to_xilem().collect::<Vec<_>>())
                                .flatten()
                                .collect::<Vec<_>>()
                                .chunks(2) // TODO: a slightly more sophisticated layout algorithm
                                .map(|chunk| {
                                    xilem_html_element(
                                        "tr",
                                        vec![syn::Expr::Tuple(syn::ExprTuple {
                                            attrs: Vec::new(),
                                            paren_token: token::Paren::default(),
                                            elems: Punctuated::from_iter(
                                                chunk.into_iter().map(|item| item.to_owned()),
                                            ),
                                        })],
                                    )
                                }),
                        ),
                    })),
                ))
                .into_iter(),
            ),
            SupportedContent::UnorderedList(list) => Box::new(
                Some(xilem_html_element(

Replacement in crates/typser/src/content.rs at line 107 [11.2939]

B:BD[2.1175] → [2.1175:1313]

                        paren_token: syn::token::Paren::default(),
                        elems: syn::punctuated::Punctuated::from_iter(

[2.1175]

[2.1313]

                        paren_token: token::Paren::default(),
                        elems: Punctuated::from_iter(

Replacement in crates/typser/src/content.rs at line 112 [11.2939]

B:BD[2.1493] → [2.1493:1564]

                                .map(|supported| supported.to_xilem())

[2.1493]

[2.1564]

                                .map(|supported| supported.to_xilem().collect::<Vec<_>>())

Replacement in crates/typser/src/content.rs at line 116 [11.2939]

B:BD[2.1660] → [2.1660:1787]

                )]
            }
            SupportedContent::OrderedList(list) => {
                vec![xilem_html_element(

[2.1660]

[2.1787]

                ))
                .into_iter(),
            ),
            SupportedContent::OrderedList(list) => Box::new(
                Some(xilem_html_element(

Replacement in crates/typser/src/content.rs at line 124 [11.2939]

B:BD[2.1915] → [2.1915:2053]

                        paren_token: syn::token::Paren::default(),
                        elems: syn::punctuated::Punctuated::from_iter(

[2.1915]

[2.2053]

                        paren_token: token::Paren::default(),
                        elems: Punctuated::from_iter(

Replacement in crates/typser/src/content.rs at line 129 [11.2939]

B:BD[2.2233] → [2.2233:2304]

                                .map(|supported| supported.to_xilem())

[2.2233]

[2.2304]

                                .map(|supported| supported.to_xilem().collect::<Vec<_>>())

Replacement in crates/typser/src/content.rs at line 133 [11.2939]

B:BD[2.2400] → [2.2400:2533]

                )]
            }
            SupportedContent::UnorderedListItem(item) => {
                vec![xilem_html_element(

[2.2400]

[2.2533]

                ))
                .into_iter(),
            ),
            SupportedContent::UnorderedListItem(item) => Box::new(
                Some(xilem_html_element(

Replacement in crates/typser/src/content.rs at line 143 [11.2939]

B:BD[2.2744] → [2.2744:2890]

                            paren_token: syn::token::Paren::default(),
                            elems: syn::punctuated::Punctuated::from_iter(

[2.2744]

[2.2890]

                            paren_token: token::Paren::default(),
                            elems: Punctuated::from_iter(

Replacement in crates/typser/src/content.rs at line 149 [11.2939]

B:BD[2.3058] → [2.3058:3189]

                )]
            }
            SupportedContent::OrderedListItem(item) => {
                vec![xilem_html_element(

[2.3058]

[2.3189]

                ))
                .into_iter(),
            ),
            SupportedContent::OrderedListItem(item) => Box::new(
                Some(xilem_html_element(

Replacement in crates/typser/src/content.rs at line 159 [11.2939]

B:BD[2.3400] → [2.3400:3546]

                            paren_token: syn::token::Paren::default(),
                            elems: syn::punctuated::Punctuated::from_iter(

[2.3400]

[2.3546]

                            paren_token: token::Paren::default(),
                            elems: Punctuated::from_iter(

Replacement in crates/typser/src/content.rs at line 165 [11.2939]

B:BD[2.3714] → [2.3714:3856]

                )]
            }
            SupportedContent::ParagraphBreak(_parahraph_break) => {
                vec![xilem_html_element(

[2.3714]

[2.3856]

                ))
                .into_iter(),
            ),
            SupportedContent::ParagraphBreak(_parahraph_break) => Box::new(
                Some(xilem_html_element(

Replacement in crates/typser/src/content.rs at line 173 [11.2939]

B:BD[2.3984] → [2.3984:4118]

                        paren_token: syn::token::Paren::default(),
                        elems: syn::punctuated::Punctuated::new(),

[2.3984]

[2.4118]

                        paren_token: token::Paren::default(),
                        elems: Punctuated::new(),

Replacement in crates/typser/src/content.rs at line 176 [11.2939]

B:BD[2.4143] → [2.4143:4176]

                )]
            }

[2.4143]

[12.2885]

                ))
                .into_iter(),
            ),

Insertion in crates/typser/src/content.rs at line 180 [11.2939]

[12.2895]

[11.4166]

    }
}
fn path_segment(segment: &str) -> syn::PathSegment {
    syn::PathSegment {
        ident: syn::Ident::new(segment, proc_macro2::Span::call_site()),
        arguments: syn::PathArguments::None,

Insertion in crates/typser/src/content.rs at line 189 [11.2939]

[11.4174]


fn expr_path(name: &str) -> syn::Expr {
    let mut segments: Punctuated<PathSegment, token::PathSep> = Punctuated::new();
    // The path should be elements::name
    // e.g. elements::h2
    segments.push(path_segment("elements"));
    segments.push(path_segment(name));
    let expr_path = ExprPath {
        attrs: Vec::new(),
        qself: None,
        path: syn::Path {
            leading_colon: None,
            segments,
        },
    };
    syn::Expr::Path(expr_path)
}
fn xilem_html_element(name: &str, expressions: impl IntoIterator<Item = syn::Expr>) -> syn::Expr {
    syn::Expr::Call(syn::ExprCall {
        attrs: Vec::new(),
        func: Box::new(expr_path(name)),
        paren_token: token::Paren::default(),
        args: Punctuated::from_iter(expressions.into_iter()),
    })
}