Playing with l3seq module, \seq_clear:N fails mysteriously, why? - TeX

TopAnswers TeX

Meta

Databases

TeX

Code Golf

APL

C++

.net

db<>fiddle

Java

*nix

PHP

PowerShell

Python

Rust

टेक्-मराठी

Typst

Web Client Dev

Web Server Dev

Playing with l3seq module, \seq_clear:N fails mysteriously, why?

add tag

निरंजन

I am working on a mechanism to segment a given string based on a particular character and then use it in some contexts. It is fairly okay in one case, but extending the mechanism to another case is failing mysteriously. I don't understand what is wrong with my code. Let's first have a look at the working code. Suppose I have to implement a font-loading-mechanism along with scaling specification. I want to create an option where suppose I input `KpSans-Regular.otf/0.5`, it should be interpreted as KpSans is to be loaded with `Scale=0.5` option. The following does that for me.

```
% arara: lualatex
% arara: lualatex
% arara: clean: { extensions: [ log,aux ] }
\documentclass{article}
\usepackage{kantlipsum,fontspec}
\usepackage{expkv-def}
\makeatletter
\ExplSyntaxOn
\seq_new:N \l_tmp_font_seq
\cs_new:Npn \tmp@split@use@fonts #1 {
  \seq_put_right:Nn \l_tmp_font_seq { #1 }
  \seq_set_split:Nnn \l_tmp_font_seq
                     { /  }
                     { #1 }
  \expandafter\newfontfamily\csname
    tmp @ \tmp@field @ font
  \endcsname[
    Scale           = {
      \seq_item:Nn \l_tmp_font_seq { 2 }
    }
  ]{
    \seq_item:Nn \l_tmp_font_seq { 1 }
  }
  \seq_clear:N \l_tmp_font_seq
}
\ExplSyntaxOff
\ekvdefinekeys{test}{
  code    font           = {%
    \tmp@split@use@fonts{#1}%
  }%
}
\NewDocumentCommand \bigkant {
  O{%
    font                 = {NewCM10-Book.otf/1}%
  }
}{%
  \def\tmp@field{big}%
  \ekvset{test}{#1}%
  \begingroup
  \tmp@big@font
  \kant[1-1]
  \endgroup
}
\NewDocumentCommand \midkant {
  O{%
    font                 = {NewCMMono10-Book.otf/0.75}%
  }
}{%
  \def\tmp@field{mid}%
  \ekvset{test}{#1}%
  \begingroup
  \tmp@mid@font
  \kant[1-1]
  \endgroup
}
\NewDocumentCommand \smallkant {
  O{%
    font                 = {NewCMSans10-Book.otf/0.5}%
  }
}{%
  \def\tmp@field{small}%
  \ekvset{test}{#1}%
  \begingroup
  \tmp@small@font
  \kant[1-1]
  \endgroup
}
\makeatother

\begin{document}
\smallkant

\midkant

\bigkant
\end{document}
```

I have tried to adhere to the "standard" practices of l3, but I won't be surprised if I miss any convention. Feel free to correct me regarding that too.

Now, I use this mechanism almost identically with `\fontsize` command and there it is failing. See the following:

```
% arara: pdflatex
% arara: pdflatex
% arara: clean: { extensions: [ log,aux ] }
\documentclass{article}
\usepackage{kantlipsum}
\usepackage{expkv-def}
\makeatletter
\ExplSyntaxOn
\seq_new:N \l_tmp_size_seq
\cs_new:Npn \tmp@split@use@sizes #1 {
  \seq_put_right:Nn \l_tmp_size_seq { #1 }
  \seq_set_split:Nnn \l_tmp_size_seq
                     { /  }
                     { #1 }
  \expandafter\def\csname
    tmp @ \tmp@field @ size
  \endcsname{
    \fontsize{
      \seq_item:Nn \l_tmp_size_seq { 1 }
    }{
      \seq_item:Nn \l_tmp_size_seq { 2 }
    }
    \selectfont
  }
  % \seq_clear:N \l_tmp_size_seq % Uncommenting fails. Why?
}
\ExplSyntaxOff
\ekvdefinekeys{test}{
  code    size           = {%
    \tmp@split@use@sizes{#1}%
  }%
}
\NewDocumentCommand \bigkant {
  O{%
    size                 = {10pt/11pt}%
  }
}{%
  \def\tmp@field{big}%
  \ekvset{test}{#1}%
  \begingroup
  \tmp@big@size
  \kant[1-1]%
  \endgroup
}
\NewDocumentCommand \midkant {
  O{%
    size                 = {7.5pt/8pt}%
  }
}{%
  \def\tmp@field{mid}%
  \ekvset{test}{#1}%
  \begingroup
  \tmp@mid@size
  \kant[1-1]%
  \endgroup
}
\NewDocumentCommand \smallkant {
  O{%
    size                 = {5pt/6pt}%
  }
}{%
  \def\tmp@field{small}%
  \ekvset{test}{#1}%
  \begingroup
  \tmp@small@size
  \kant[1-1]%
  \endgroup
}
\makeatother

\begin{document}
\smallkant

\midkant

\bigkant
\end{document}
```

Why does `\seq_clear:N` fail now? What's the difference between the two situations?

the thing is that my code is most of the time rather bare bones, most of the code I wrote in `expl3` was/is for the kernel and should be as fast as feasibly possible, hence it uses a bunch of low level optimisations like currying, which is not possible with `:Nn`.

This is for a package which has three levels. One is the code-level where I use `expl3`-like macros. Then an intermediate level where I create 2e style internal commands. They are to be used by my colleagues who don't know l3 and the last one is where usual user side macros without `@`s and `_`s are used.

`\exp_not:n` grabs a single argument, removes the braces around it, and everything in that argument won't expand. `\exp_not:N` only applies to a single token (`N`-type argument), everything else is fully expanded inside the `\edef`-context. If you want to use `expl3` you shouldn't use `\edef` directly, neither should you need `\expandafter` or `\csname`. Instead you should use the following: ``` \cs_set:cpx { tmp @ \l_tmp_field_tl @ size } { \exp_not:N \fontsize { \exp_not:V \l_tmp_size_tl pt } { \exp_not:V \l_tmp_blsk_tl pt } \exp_not:N \selectfont } ``` Or if you're directly accessing the sequence elements: ``` \cs_set:cpx { tmp @ \l_tmp_field_tl @ size } { \exp_not:N \fontsize { \seq_item:Nn \l_tmpa_seq { 0 } pt } { \seq_item:Nn \l_tmpa_seq { 1 } pt } \exp_not:N \selectfont } ```

Interesting. I had figured that out that I will need `\exp_not`, but my failed attempt was this: ``` \expandafter\edef\csname tmp @ \tmp@field @ size \endcsname{ \exp_not:n { \fontsize{ \seq_item:Nn \l_tmp_size_seq { 1 } }{ \seq_item:Nn \l_tmp_size_seq { 2 } } \selectfont } } ``` I can kind of see why this could happen, but this raises several interesting questions for me. 1. Suppose I say `\exp_not:N \foo{abcd\efgh}`. Does this mean `\foo` along with its argument is _not expanded_ or just `\foo` is _not expanded_? What would _not expanding_ `\foo` but expanding its argument mean? 2. The idea you suggested works. So the following is what I have right now: ``` \expandafter\edef\csname tmp @ \tmp@field @ size \endcsname{ \exp_not:N \fontsize{ \tl_use:N \l_tmp_size_tl pt }{ \tl_use:N \l_tmp_blsk_tl pt } \exp_not:N \selectfont } ``` and it seems like the situation I described. We had two things which we didn't want to expand (`\selectfont` and `\fontsize`). If we say `\exp_not:N` also protects the arguments, the former and the latter should be identical, right? Because technically everything inside the argument is unexpanded. So why does the former approach fail?

@निरंजन, re: [your question](#question), Note that your `\seq_put_right:Nn \l_tmp_size_seq {#1}` is essentially doing nothing as the very next line `\seq_set_split:Nnn \l_tmp_size_seq { / } {#1}` overrides all of the former effects (except for the time lost). You can just drop that `\seq_put_right:Nn`.

in the first case you are calling `\newfontfamily` and use the seq items directly. In the second case you define a command which uses the seq items, then clear the seq, and then try to use the command which then calls \fontsize with empty arguments.

0 Answers