Is it possible to store a dictionary in a .chezmoi.yaml.tmpl data variable?

[eugenesvk]

I've got confused by a somewhat basic chemoi variable type question: what data types can I store in chezmoi data? I'd like to programmatically generate a dictionary and then use it in other templates (below is an example of a manually generated dictionary)

.chezmoi.yaml.tmpl

data:
 mydict    	: #{{ dict "key" 12  }

But then when I try to use it

#{{ get .mydict "key" }}

I get a type mismatch error wrong type for value; expected map[string]interface {}; got string
while local dict works

#{{ $t := dict "key" 12  }}
#{{ get $t "key" }}

and just importing it

#{{  .mydict  }}

gives me map[key:12] which seems to indicate that this is a data structure, not a string?

Tangentially related: is it possible to export a variable from a template? Then I could stuck some common $t in a template and then just use it {{{$import := template xxx}}
I know you can pass dictionaries to templates, but is it possible to extract dictionaries from them?

[halostatue]

Absolutely. I take advantage of this in my .chezmoitemplates/programs.tmpl to cache all of my lookPath operations (some of them are used in multiple templates; I know that chezmoi caches the result).

The main thing to know is that only strings can return from templates, so you have to convert it to JSON (| toJson) and when you import it, you need to convert it from JSON ($x := importTemplate "programs.tmpl" | fromJson).

For your example, you would need to do

data:
  mydict: #{{ dict "key" 12 | toJson }}

I’m using TOML for my config file, which makes things somewhat uglier for keeping data clean between two different calls of chezmoi init as you can see in https://github.com/halostatue/dotfiles/blob/main/home/.chezmoi.toml.tmpl.

[eugenesvk]

only strings can return from templates, so you have to convert it to JSON

Thanks, that's the part I was missing, I thought looking at the default variables https://www.chezmoi.io/reference/templates/variables/ it had strings and integers and objects, not just strings, so I thought it wasn't as limited to need a serialization

Also, I mistakenly thought I could use lists there because of this test

define

data:
  mylist: #‹ list "a" "b" ›

use: "works", get "a b"

#‹ $x := .mylist ›
#‹ $x | quoteList | join ", " ›

(but no ,, so it's just parsing it as a regular string)

cache all of my lookPath operations (some of them are used in multiple templates; I know that chezmoi caches the result).

this is exactly my use case, and it's nice to know that the results are cache as I thought I'd need to move it to data and chezmoi init on path updates to avoid multiple calls doing multiple lookups

Although the original example doesn't work with fromJson, but it works without it!

# fails↓ with at <fromJson>: wrong type for value; expected string; got map[string]interface {}
#‹ $x := .mydict | fromJson ›
# succeeds↓
#‹ $x := .mydict ›
#‹ get $x "key" ›

(and minor typo $x := includeTemplate "path" . | fromJson not importTemplate)