如何在带有 expl3 的条件函数中使用变量？

Question 1

中的布尔表达式expl3通过扩展工作，因此它们只能在实现中包含可扩展函数：这些函数在中用星号标记interface3.pdf。最重要的是，赋值是不是可扩展：因此你不能用它们来实现谓词。能实现不可扩展的分支测试，例如\tl_if_eq:nn(TF)使用\prg_new_protected_conditional:Nnn

Answer

中的布尔表达式expl3通过扩展工作，因此它们只能在实现中包含可扩展函数：这些函数在中用星号标记interface3.pdf。最重要的是，赋值是不是可扩展：因此你不能用它们来实现谓词。能实现不可扩展的分支测试，例如\tl_if_eq:nn(TF)使用\prg_new_protected_conditional:Nnn

Question 2

Joseph Wright 已经指出你不能让 TeX在作为第一个参数
\int_set:Nn \l_tmpa_int { 3 } 处理的条件/宏内执行操作：\bool_if:nTF

\bool_if:nTF对处于扩展阶段的事物进行评估 — — 用 Donald E. Knuth 的比喻来说，TeX 是一个有眼睛、嘴巴和消化道的有机体，在 TeX 的食道中发生，就像一个“反刍”的过程 — — 并“期望”由此获得一个标记\prg_return_true:/ \prg_return_false:。

\int_set:Nn意味着分配。分配不会在扩展阶段发生，而是在 TeX 处理的后期阶段发生，此时标记已经到达 TeX 的胃中。

扩展的同时还有调用\my_is_prime:n和传递的情况意味着除了其中一个标记/之外的例程还会遇到由触发的形成赋值的不可扩展标记。\int_set:Nn\bool_if:nTF\my_is_prime:n\bool_if:nTF\prg_return_true:\prg_return_false:\int_set:Nn

interface3.pdf 包含注释

TeXhackers 注释：与等不同，bool 数据类型不是使用\iffalse/基元实现的，在纯 TeX、LaTeX 2ε 等中。程序员不应根据对实现的任何特定期望来使用 bool 开关。\iftrue\newif

我还没有仔细研究布尔数据类型的实现。我猜想在扩展链中\bool_if:nTF内部使用\prg_return_true:/ ，在某个阶段应该会产生一些 TeX-\prg_return_false:⟨数字⟩-数量，并且由于形成触发的分配的不可扩展标记而被破坏\int_set:Nn，因此产生! Missing number, treated as zero.-错误。

expl3 旨在让您更轻松地控制扩展。因此，我很高兴看到\exp_args:Nno/ \exp_args:Nnf/... 函数，它可以与结合使用\use:n。
通过这种方式，您可以通过嵌套调用来操作应一个接一个放置的参数，就像放置在之后的
\exp_args:Nno\use:n{...}{further to-be-manipulated argument}
参数一样。最内层表达式的参数包含宏标记，用于放置在所有（从而应用于所有）被操作的参数之前。{...}\use:n
{...}\exp_args:Nno\use:n{...}{further argument}

例如，

\cs_new:Npn \foo {foo}
\cs_new:Npn \bar {bar}

代码

\exp_args:Nno\use:n{
  \exp_args:Nno\use:n{
    \macro
  }{\bar}
}{\foo}

产量：

\use:n{
  \exp_args:Nno\use:n{
    \macro
  }{\bar}
}{foo}

产量：

  \exp_args:Nno\use:n{
    \macro
  }{\bar}
{foo}

产量：

  \use:n{
    \macro
  }{bar}
{foo}

产量：

    \macro
  {bar}
{foo}

如果您坚持使用 expl3 而不是 Lua，那么为了好玩，您可以执行可扩展的 Eratosthenes 来枚举素数。

以下实现只是一个起点，需要优化：

可处理的数字范围\int_eval:n不是那么大。
发生平方后数字的范围会减小。
出现分裂会使进程减慢。

正如我所说，这只是为了好玩。如果它只涉及\numexpr/可处理的数字范围\int_eval:n，那么在实际场景中，我绝对不会实现计算素数，而是实现从硬编码的表/列表中查找素数。

\ExplSyntaxOn

\cs_new:Nn \__UD_eratosthenes_mainloop:nnnn {
  % #1 - <remaining list of numbers from which primes shall be sieved>
  % #2 - <upper bound>
  % #3 - <list of primes already found>
  % #4 - <command for printing list of primes>
  \int_compare:nNnTF {(\tl_head:n {#1})*(\tl_head:n {#1})}>{#2}
  { \exp_end:#4{#3#1} }{
    \exp_args:Nnf \use:n { \__UD_eratosthenes_newlist:nnnwn {\use_i:nn} #1{!}!{}{#2} }
                         { \exp_args:Nnf \use:n {#3}{\tl_head:n {#1}} }{#4}
  }
}
\cs_new:Npn \__UD_eratosthenes_newlist:nnnwn #1#2#3#4!#5 {
  % #1 = \use_i:nn/\use_ii:nn - fork which test to perform
  % #2 = <prime number whose multiples are to be eliminated>
  % #3 = <smallest number from remaining list of numbers from which primes shall be sieved>
  % #4 = <remaining list of numbers from which primes shall be sieved>
  % #5 = <new list of numbers from which primes shall be sieved>
  \exp_args:Nf \str_if_eq:nnTF {\tl_head:n {#3}} {!}
  {\__UD_eratosthenes_mainloop:nnnn{#5}}{
    #1 {\int_compare:nNnTF {(#2)*(#2)}>{#3}\use_ii:nn\use_i:nn}
       {\int_compare:nNnTF {((#3)/(#2))*(#2)}={#3}}
    {
      #1{\__UD_eratosthenes_newlist:nnnwn{\use_ii:nn}{#2}{#3}}
        {\__UD_eratosthenes_newlist:nnnwn{#1}{#2}}#4!{#5}
    }
    {\__UD_eratosthenes_newlist:nnnwn{#1}{#2}#4!{#5{#3}}}
  }
}
\cs_new:Nn \__UD_eratosthenes_numberlist:n {
  \int_compare:nNnTF {#1} > {1} 
  { \exp_args:Nno \use:n {\exp_args:No \__UD_eratosthenes_numberlist:n } {\int_eval:n {#1-1}}{#1} }
  { \exp_end: }
}
\cs_new:Npn \primeslist #1#2 {
  \exp:w \exp_args:Nno \use:nn {\exp_end:} {
    % Hide things in braces because the user might supply #2/<tokens> that otherwise might
    % disturb tabulars/alignments etc.
    \exp:w  \int_compare:nNnTF {#1} < {2} 
            { \exp_end: #2{} }{
              \int_compare:nNnTF {#1} = {2} 
                               { \exp_end: #2{{#1}} }
                               {
                                 \exp_args:No \__UD_eratosthenes_mainloop:nnnn
                                           {\exp:w \__UD_eratosthenes_numberlist:n {#1}}
                                           {#1} {} {#2}
                               }
            }
  }
}
% \primeslist{<upper bound>}{<tokens>} after two expansion-steps yields:
% <tokens>{{2}{3}...{p_k; p_k < upper bound <= p_(k+1)}}

\cs_new:Npn \prettyprintcommand #1#2#3#4 {
  % #1 tokens before each item
  % #2 tokens behind each item
  % #3 tokens between items
  % #4 list of items formed by undelimied arguments
  %    Items must not contain "!" which is the case for decimal numbers represented by arabic numerals.
  \__UD_prettyprintloop:nnnnn{#1}{#2}{#3}{}#4{!}
}
\cs_new:Nn \__UD_prettyprintloop:nnnnn {
  \exp_args:Nf \str_if_eq:nnTF {\tl_head:n {#5}} {!}
  {}{  #4#1#5#2  \__UD_prettyprintloop:nnnnn{#1}{#2}{}{#3#4} }
}

\ExplSyntaxOff

\message{^^J}

\message{^^J\primeslist{1}{<tokens in front of prime-list>}}

\message{^^J}

\message{^^J\primeslist{2}{<tokens in front of prime-list>}}

\message{^^J}

\message{^^J\primeslist{100}{<tokens in front of prime-list>}}

\message{^^J}

\message{^^J\primeslist{100}{\prettyprintcommand{(}{)}{; }}}

\message{^^J}

\stop

终端输出：

<tokens in front of prime-list>{} 

<tokens in front of prime-list>{{2}} 


<tokens in front of prime-list>{{2}{3}{5}{7}{11}{13}{17}{19}{23}{29}{31}{37}{41
}{43}{47}{53}{59}{61}{67}{71}{73}{79}{83}{89}{97}} 


(2); (3); (5); (7); (11); (13); (17); (19); (23); (29); (31); (37); (41); (43);
 (47); (53); (59); (61); (67); (71); (73); (79); (83); (89); (97)

Answer