ty

Why did I write that?

Anyways, is a a good way of making nested structures in expl3. Kinda like having an array of hash references in Perl. I have some data, which is collected one block at a time (it is some env contents, and some values of local configuration), which needs to be collected in order, and then at the end, loop over the list and typeset each blocked.

@daleif is that a question?

@Skillmon it is. Just looking at where it made sense to make say a sequence of prop vars. Just not quite sure what is the best approach.

I did the old version using etoolbox lists where each element was a \def\foo{value}\def\bar{value}.., and when looking you just grapped an element and ran it. Trying to so something similar.

Pointers to existing projects are fine

@daleif you could serialise props to keyval using \prop_to_keyval:N and deserialising using \prop_set_from_keyval:Nn and store the serialised data in a seq.

@Skillmon good idea, forgotten about that one. I'll do some tests.

@daleif Well, you need some form of serialisation here, another aproach (albeit a bit harder to handle) would be a token list in which you use positional items for each nesting level or a clist (also with positional access). Doesn't sound like fun.

@daleif there is also a package which tries to implement some more high level data structure based on expl3, but I forgot its name -- I remember however that I opened a ticket on their GH because it relied on implementation details.

(something which is fixed, afaik)

In my case I have a parent env, lets call it Parent, and Child envs each of which may set optional arguments. I'd like for each Child to collect the body and the key val data, and be able to use it later in the order it was found (the child blocks, not their key val).

ooh möööööö

@PauloCereda This reminds me of vimeo.com/492532561#t=120s :)

@PauloCereda I'd say they say "mu".

@mickep only Greek cows say that

@PauloCereda muh

@PauloCereda dinner

@DavidCarlisle but only while whispering.

@daleif seems rather simple to do that in a seq which stores two tl-items per item:

\ExplSyntaxOn
\bool_new:N \l_daleif_in_parent_bool
\seq_new:N \l_daleif_children_seq
\tl_new:N \l_daleif_body_tl
\keys_define:nn { daleif-child }
  {
    % whatever necessary
  }
\msg_new:nnn { daleif } { not-in-Parent }
  { Child~ used~ outside~ of~ Parent~ environment }
\cs_new_protected:Npn \__daleif_output_children:
  {
    \seq_map_inline:Nn \l_daleif_children_seq { \__daleif_output_child:nn ##1 }
  }
\cs_new_protected:Npn \__daleif_output_child:nn #1#2
  {
    \keys_set:nn { daleif-child } {#1}

(above code most likely misses some grouping in \__daleif_output_child:nn)