How to use variables in eval, when variables are defined in another document?

Questions
1

Hi,

I want to create a document where the content will be stored in YAML files. However the YAML file may contain variables that should be defined in the main Typst file.

Here is an example of Typst file:

#let content = yaml("content.yaml")
#let stuff = "Stuff"

#eval(content.content, mode: "markup")

And the content.yaml file:

content: |
  It _appears_ that the #stuff matters.

When compiling, I get this error:

error: unknown variable: stuff
  ┌─ test.typ:4:6
  │
4 │ #eval(content.content, mode: "markup")
  │       ^^^^^^^^^^^^^^^

So, #stuff is correctly identified as a variable, but the issue is that the eval function seems not to take into account the calling environment.

In order to fix this, I need to provide a scope parameter to the eval function, such as:

#eval(content.content, mode: "markup", scope: (stuff: stuff))

However my framework is slightly more complicated in practice and the eval function is called in a package that should not know the variables that are defined in the main document (and the package shouldn’t even know about the main document). Therefore, how to achieve the same behaviour, with the constraint that we cannot ask the package to load variables from the main document?

Thanks!

2

The reason for eval not being able to access arbitrary variables is because (AFAIK) security reasons.

But if I understand your question correctly, you are calling eval inside a package which is itself inside main? If so, you can just define the scope (a dictionary) in main, and pass that to the package (which would then pass it to eval)

3

Thanks for your reply! And sorry, I didn’t make that clear.

Let’s assume I have three files:

  1. the main file: main.typ
  2. a package: mypackage.typ
  3. a YAML file with the content: content.yaml

The content of main.typ:

#import "./mypackage.typ": *
#let content = yaml("content.yaml")
#let stuff = "Stuff"

#display(content)

The content of mypackage.typ:

#let display(content) = {
    eval(content.content, mode: "markup")
}

And the content of content.yaml:

content: |
  It appears that #stuff matters

So, indeed I would like to pass all the variables/functions to mypackage but the problem is that I don’t know how to pass the dictionary of the scope to mypackage.typ.

Thanks again!

4

Would something like this work for you?

main.typ:

#import "./mypackage.typ": *
#let content = yaml("content.yaml")
#let stuff = "Stuff"

#let scopedict = (
  stuff: stuff,
)

#display(content, scopedict)

mypackage.typ:

#let display(content, scope) = {
    eval(content.content, mode: "markup", scope: scope)
}

With content.yaml being defined as before. If you’re seeking a way to maintain the scope dictionary automatically, you’ll have to program your own external tools

1 Like
5

Thanks! Is there a way to include all the variables from the scope, without explicitly adding them to the dictionary?

Something similar to

#import "imports.typ" as imported
#let scopedict = dictionary(imported)

but instead of imports.typ it would only import what is declared so far in the current document? Otherwise, I would move my variable declarations in another file.

Thanks again!

6

Sadly, I don’t think there’s currently a way of finding all variables in scope

1 Like