Is it possible to use a dictionary as a typst element's properties?

Questions
1

This question is so simple that I am embarrassed for not having the answer myself. I’d like to know what would be the correct way to use a dictionary in a variable as the property dictionary that typst elements usually expect. For example (assuming that we are already in code mode):

let boxprops = (
  inset: 1mm,
)

box(
  boxprops
)[
Content
]

This does not work because the box element does not have a property with name props.

So what would be the correct way?

I am not interested in solutions like the following:

let boxprops = (
  inset: 1mm,
)

box(
  inset: boxprops.inset,
)[
Content
]

The reason is that the boxprops variable -depending on the situation- can contain an arbitrary number of dictionary entries, from 0 entries up to the full set of entries that are valid for a box element.

Of course, there are complicated and ugly ways to construct a box element from a dictionary in a variable. But I’d like know if there is an easy and elegant one that I have missed.

Thank you very much in advance!

P.S. This is a general question that applies to all typst elements. The box element was just an example.

2

Hi! This trick is to ..spread:

let boxprops = (
  inset: 1mm,
)

box(..boxprops)[
  Content
]

An alternative solution is function.with:

let your-box = box.with(
  inset: 1mm,
)

your-box[
  Content
]

By the way, AI services like https://deepwiki.com/typst/typst and Typst (websites/typst_app) | Context7 have full access to the Typst Documentation. For simple questions like this one, you can use these services to get the answer more quickly.

3

Another option is to use the argument type. From what I can see the only(?) benefit compared to a dictionary is you can include positional arguments too.

From the documentation:

#let args = arguments(stroke: red, inset: 1em, [Body])
#box(..args)
4

@Y.D.X

I see. Thank you very much. I had totally forgotten about argument spreading. Shame on me … had used it before, but had to focus on other tasks during the last weeks.

Regarding research, I had googled for the solution before posting of course. But obviously I had used the wrong keywords.

@gezepi

Thank you very much, too. I had not come across the argument type yet. It looks promising. But I still have to check whether it works if I pass a variable which already contains a dictionary to the arguments() function. Like this: #let args = arguments(boxprops,[body]). Otherwise, I couldn’t use it in my specific case.

5

My thought was actually that you could use the argument type instead of a dictionary. But that depends entirely on your specific context.

6

The problem has been solved yesterday, but you seem to be interested in the motivation, so here we go (I’ll show one use case regarding the box element, but actually the problem and the solution are very general):

I have a function that creates (returns) a box. That function (among others) takes a width parameter. That parameter shall determine the box’s width.

However, the calling code may leave away the width parameter when calling the function. In that case, I don’t want to include the width property into the box properties as well. Rather, the “default” or “current” width value for boxes (as determined by typst itself, or by set or show rules) should be used.

This means that I don’t know in advance which entries the dictionary with the box properties has. This is the key point: The problem is not that I don’t know the box property values in advance. The problem is that I don’t know in advance whether or not a certain box property must be set at all.

Argument spreading is the right tool to solve this problem. Minimal example:

#let mybox(width: none) = {

  let props = (:)
  if (none != width) {
    props.width = width
  }

  box(
    ..props,
    [foo bar baz]
  )
}

The code above behaves exactly as I need.

I am aware that I could have solved this general problem another way (without argument spreading) in this specific case, because the width property for a box can be set to auto, which achieves the same effect under normal circumstances:

#let mybox(width: none) = {

  let w = auto
  if (none != width) {
    w = width
  }

  box(
    width: w,
    [foo bar baz]
  )
}

However, there are two arguments against that approach:

First, it could conflict with other document-wide rules (e.g., show or set) that assign a default width to a box (e.g., 10mm). These other rules would be overridden by setting width: auto.

Second, there are other properties that are neither allowed to be set to auto,nor does another default value exist they can be set to. In such cases, the above code structure is not appropriate, and we need argument spreading. An example for such a property is inset.

In such situations, the only alternative I can think of would be to put the respective code into a context, to query the current value of the respective property in that context, and to use that value as the value for the respective dictionary entry when constructing the element in question.

The latter would be extremely unpleasant and cumbersome, though, and in addition would impose all the ugly problems that are associated with a context (e.g., that it is opaque and that its return value practically cannot be used in further programmatic processing). Plus, I suspect problems with that method if the respective property hasn’t been set explicitly (yet). I don’t plan to try that approach, because argument spreading is so much superior in such situations.