Struggeling with creating code chunks prgramatically (why not cat everthing, and how to include execute options?)

[setseed13]

Description

Hey!

I want to create code chunks programmatically, and started with the following example from stackoverflow

---
title: "Programmatically Generating Code Chunks"
format: html
echo: false
output: asis
warning: false
---


## Summary list

Code to make a bunch of example models.

```{r}
#| echo: false

# A list of summaries:
library(palmerpenguins)

summary_list <- penguins |>
  split(penguins$species) |>
  lapply(function(dat){
    lm(flipper_length_mm ~  body_mass_g, data = dat)
  }) 

headings <- names(summary_list)

```

## Summary tabs

:::{.panel-tabset}

```{r, results='asis'}
#| warning: false
for (i in seq_along(summary_list)) {
  cat("# ",headings[i],"\n")
  cat("```\n")
  print(summary(summary_list[[i]]))
  cat("\n```\n")
  cat("\n\n")
}
```

:::

This works as expected. At first. The more I dug into it, the more I got lost.
First of all, what's the deal with echo? (at the bottom I included a code chunk which holds all of the ones I'm going to show for easy rendering)

## tabsets make the echo disapear?

:::{.panel-tabset}

```{r}
#| warning: false
#| echo: true
for (i in seq_along(headings)) {
  cat("### ", headings[i],"\n")
  cat("```\n")
  print(headings[i])
  cat("\n```\n")
  cat("\n\n")
}
```

:::

I also don't understand why not everything is cated. IIRC the knitr documentation, everything in the file gets evaluated (rendered) at very specific points in time, so I'd expect the above chunk to be evaluated at once, and as such I though that it should look like this:

## why `print(headings[i])` instead of `cat("print(headings[i])")`

```{r}
#| warning: false
for (i in seq_along(headings)) {
  cat("### ",headings[i],"\n")
  cat("```\n")
  cat("print(headings[i])")
  cat("\n```\n")
  cat("\n\n")
}
```

When I wanted to investigate, I first got rid of the loop...and discovered that the example, which I pulled, uses cat("```\n") instead of, as I would expect, cat("```{r}\n"). Why is there no difference?

## lose the loop

```{r}
#| warning: false
  cat("```\n")
  print(headings[1])
  cat("\n```\n")
  cat("\n\n")
```

versus

## lose the loop with "```{r}```"
```{r}
  cat("```{r}\n")
  print(headings[1])
  cat("\n```\n")
  cat("\n\n")
```

Now, where are getting to the problem that started this all: including execute options.

## include "include = false"

```{r}
  cat("```{r}\n")
  cat("#| include: false\n")
  print(headings[1])
  cat("\n```\n")
  cat("\n\n")
```

cat("#| include: false\n") is not turned into an execute option, but plain text. I assume this is a timing issue?

As per the suggestion of a stafckoverflow user I tried the following

## include "include = false" differently (inconsistent interpretations of the steps in the loop?)

```{r}
for (i in seq_along(headings)) {
  cat("```{r, include=FALSE}\n")
  print(headings[i])
  cat("\n```\n")
  cat("\n\n")
}
```

When I wanted to change some things around, I copy pasted that chunk, and just knitted the doc without actually changing something. Apparently, this breaks the styling.

## same chunk as above, but this time the header styling is broken

```{r}
for (i in seq_along(headings)) {
  cat("```{r, include=FALSE}\n")
  print(headings[i])
  cat("\n```\n")
  cat("\n\n")
}
```

## styling is back

Lastly, since print() needs no cating I tried not cating #| include: false, which turns it into a comment I guess, because it's not rendered, but the code beneath it is:

## styling is back

```{r}
for (i in seq_along(headings)) {
  cat("```{r}\n")
#| include: false
  print(headings[i])
  cat("\n```\n")
  cat("\n\n")
}
```

I suspect that this is either an issue of timing in terms of the knitr pipeline, or, as the second to last chunks seem to suggest a problem with fencing the chunks?
I looked around, and apparently the proper way of handling such things looks more like the code in this issue, than what I tried.

To wrap this up: I want to create code chunks programmatically, but lack understanding of...well, it's of everthing.
I appreciate any and all help :)

My specs:
Windows 10
R 4.3.2
RStudio 2023.12.1 Build 402
VSCode 1.86.0 with Quarto 1.4.549

Here are the chunks from above in a single doc:

---
title: "Programmatically Generating Code Chunks"
format: html
echo: false
output: asis
warning: false
---


## Summary list

Code to make a bunch of example models.

```{r}
#| echo: false

# A list of summaries:
library(palmerpenguins)

summary_list <- penguins |>
  split(penguins$species) |>
  lapply(function(dat){
    lm(flipper_length_mm ~  body_mass_g, data = dat)
  }) 

headings <- names(summary_list)

```

## Summary tabs

:::{.panel-tabset}

```{r, results='asis'}
#| warning: false
for (i in seq_along(summary_list)) {
  cat("# ",headings[i],"\n")
  cat("```\n")
  print(summary(summary_list[[i]]))
  cat("\n```\n")
  cat("\n\n")
}
```

:::

## tabsets make the echo disapear?

:::{.panel-tabset}

```{r}
#| warning: false
#| echo: true
for (i in seq_along(headings)) {
  cat("### ", headings[i],"\n")
  cat("```\n")
  print(headings[i])
  cat("\n```\n")
  cat("\n\n")
}
```

:::

## why `print(headings[i])` instead of `cat("print(headings[i])")`

```{r}
#| warning: false
for (i in seq_along(headings)) {
  cat("### ",headings[i],"\n")
  cat("```\n")
  cat("print(headings[i])")
  cat("\n```\n")
  cat("\n\n")
}
```


## lose the loop

```{r}
#| warning: false
  cat("```\n")
  print(headings[1])
  cat("\n```\n")
  cat("\n\n")
```

## lose the loop with "```{r}```"

```{r}
  cat("```{r}\n")
  print(headings[1])
  cat("\n```\n")
  cat("\n\n")
```

## include "include = false"

```{r}
  cat("```{r}\n")
  cat("#| include: false\n")
  print(headings[1])
  cat("\n```\n")
  cat("\n\n")
```

## include "include = false" differently (inconsistent interpretations of the steps in the loop?)

```{r}
for (i in seq_along(headings)) {
  cat("```{r, include=FALSE}\n")
  print(headings[i])
  cat("\n```\n")
  cat("\n\n")
}
```

## same chunk as above, but this time the header styling is broken

```{r}
for (i in seq_along(headings)) {
  cat("```{r, include=FALSE}\n")
  print(headings[i])
  cat("\n```\n")
  cat("\n\n")
}
```

## styling is back

```{r}
for (i in seq_along(headings)) {
  cat("```{r}\n")
#| include: false
  print(headings[i])
  cat("\n```\n")
  cat("\n\n")
}

[mcanouil]

(I did not read all)

You need to use knitr::knit_child (and eventually knitr::knit_expand), see https://bookdown.org/yihui/rmarkdown-cookbook/child-document.html.
That's how knitr works.

Related discussions: https://github.com/quarto-dev/quarto-cli/discussions?discussions_q=knit_child

On a side note:
Don't mix code cell options syntaxes, inline R syntax and YAML syntax:

```{r, results='asis'}
#| warning: false
for (i in seq_along(summary_list)) {
  cat("# ",headings[i],"\n")
  cat("```\n")
  print(summary(summary_list[[i]]))
  cat("\n```\n")
  cat("\n\n")
}
```

Use

```{r}
#| warning: false
#| output: asis
for (i in seq_along(summary_list)) {
  cat("# ",headings[i],"\n")
  cat("```\n")
  print(summary(summary_list[[i]]))
  cat("\n```\n")
  cat("\n\n")
}
```

[setseed13]

Well, this certainly works, thank you so much for your help, as well as your side note!

Quick follow-up question, if I may:
knitr::knit_child versus knitr::knit_expand:
any suggestions when to use one over the over? I assume, when looping knitr::knit_expand is preferred so that there are not needlessly many renderings? Any other reason?

PS: since this is also an open question on stackoverflow, if you answer there, I'd accept it. Otherwise, I answer it myself.

[mcanouil]

The two are différents, see the documentation of those functions which will explain better than me.

[cderv]

knit_expand() is just a template function (like glue package or whisher or brew). It will replace some marked text by value evaluated as text.

knit_child() is a knitr specific function to run knit() within a main knitting process. This is what powers child document mode in knitr (child cell options), but it can also be called on text content or document as an R function. It only works within knitting context - you can't call it outside. This insure that some content will be handled as expected by knitting process (it is not juts text replacement but follow the knitting print rules (https://cran.r-project.org/web/packages/knitr/vignettes/knit_print.html) and handles some specific things required for knitr output)

Hope it clarifies