Equivalent to Knitr cat for Jupyter engine?

[JasonPekos]

When working with R + Knitr documents, I can cat code chunks to external files.

For example, I can write a Stan model in one chunk:

```{stan, model}
#| output.var: neal
#| eval: false

parameters{
  real y;
  vector[9] x;
}
model {
  y ~ normal(0, 3);
  x ~ normal(0, exp(y/2));
}
```

If I want to sample from this model using cmdstan instead of rstan, in Julia instead of R, I can send the code chunk to an external .stan file:

```{cat}
#| engine.opts: !expr list(file='model.stan')
#| class.source: 'stan'
#| echo: false

<<model>>
```

and then read that back into my Julia code chunk. This allows me to present syntax-highlighted Stan models without re-typing code in two different places.

I'm wondering if there's an easy way to get the same result — writing a chunk which I import into another chunk as a file or string — while using the Jupyter engine.

Knitr + JuliaCall seems to require that I install the arm version of Julia on my laptop for compatibility reasons (instead of just emulating x86), which seems like a bad idea, as that Julia branch still has some stability issues.

[mcanouil]

The equivalent of the cat engine of knitr would be the "magic commands" for Jupyter Notebook, and in your case it is %%writefile example.txt that you have to insert in the cell.
The question is, does Quarto handle the magic commands/functions? I think it does but cannot test it now.

[jjallaire]

Yes, Quarto doe s indeed handle magic commands/functions.

[JasonPekos]

This seems super promising! Unfortunately it doesn't seem to work for my specific case, as unlike Knitr, the Jupyter engine can't render Stan code chunks. More importantly, %%magic also won't work in non-Python chunks (including Julia chunks), or Python chunks which are unevaluated. So, as the Stan code isn't valid Python, I can't simply write up some Python cell that looks like this:

```{python}
#| eval: false
%%writefile model.stan

model {
  # stan code goes here
}
```

And even if I could, it wouldn't look great in my rendered document.

I tried messing around with this, which allows me to essentially turn Python cells into Stan cells, but

1. I still don't get .stan style highlighting in the render
2. This seems to break the %%writefile magic ... if I call %%writefile after the Stan magic, it won't write anything, and if I call %%writefile before the Stan magic, my written file is no longer valid Stan code, as it keeps the %%stan header.

---

As an additional (related) note, rendering Julia code with strings seems to behave incorrectly, e.g.

```{julia}
model = "parameters{
  real y;
  vector[9] x;
}
model {
  y ~ normal(0, 3);
  x ~ normal(0, exp(y/2));
}";
``` 

Should probably render as:

(Image is an {r} chunk with Knitr)

Instead, part of the string seems to be rendered as code:

[mcanouil]

For %%writefile to work, the cell has to be evaluated (this is also true when using Jupyter Notebook outside of Quarto).
To note: the magic commands is evaluated, but not the content below it.
If you do not want the cell to show anything, then use any of the options to control the output: message, include, etc.

Regarding the styling/highlight issue, it would be better for Quarto's devs if you open an actual (and separate) issue with a full reproducible example (not screenshots).