User-Agent: Mozilla/5.0 (Macintosh; U; Intel Mac OS X 10.6; sv-SE; rv:1.9.2.15)
            Gecko/20110303 Thunderbird/3.1.9
MIME-Version: 1.0
References: <905C5ED0-6639-4DEB-95AC-A2FCB2C4491D@gmail.com>           
            <AANLkTinSd4KS9gbk_cBPseFjbTFfSmSJUgYJUUP_vpBZ@mail.gmail.com>     
            <E8A13BAD-6790-4966-9BAF-379E21DD249C@gmail.com>           
            <AANLkTin1PWjtDuxug+ZjGKKg=VBbuz7Pf12rCkAo9+ex@mail.gmail.com>     
            <AANLkTinh=zgNFCYWuGwO4mCsL6a7Yezxec264DmWwabk@mail.gmail.com>     
            <935A1EA2-C971-4A3A-8DF4-6F890E0CFB32@gmail.com>           
            <5256FD2C-CD53-4FF0-A405-5B8B2781E5EC@gmail.com>           
            <AANLkTinfC5YVmG57GhGsFAddi1jy7PiZ+6cjV1Wx7KCD@mail.gmail.com>     
            <A30A1074-CC53-495E-864C-91180793D8FB@gmail.com>           
            <AANLkTi=KxLLEnwJsUzXe9rujQqnFX+rEFWRQq3o=v1_N@mail.gmail.com>
            <19843.17637.935263.780194@morse.mittelbach-online.de>
Content-Type: text/plain; charset=ISO-8859-1; format=flowed
Content-Transfer-Encoding: 8bit
Message-ID:  <4D835315.3040004@residenset.net>
Date:         Fri, 18 Mar 2011 13:41:57 +0100
Reply-To: Mailing list for the LaTeX3 project
              <LATEX-L@listserv.uni-heidelberg.de>
Sender: Mailing list for the LaTeX3 project <LATEX-L@listserv.uni-heidelberg.de>
From: =?ISO-8859-1?Q?Lars_Hellstr=F6m?= <Lars.Hellstrom@RESIDENSET.NET>
Subject: Re: expl3's seq_pop_right etc.
To: LATEX-L@listserv.uni-heidelberg.de
In-Reply-To:  <19843.17637.935263.780194@morse.mittelbach-online.de>
Precedence: list
Status: R

Frank Mittelbach skrev 2011-03-18 12.41:
>   >  - I'd like every "..._map_function:NN" to become
>   >  "..._map_function:Nn", i.e. allow mapping several tokens at a time. It
>   >  isn't difficult to adapt the code for that, and it would be quite
>   >  practical, since among the mappings, only the "map_function" are
>   >  expandable. For that reason, "\seq_map_function:NN" is not defined in
>   >  the file I attach.
>
> Personally I don't find this very intuitive; if you map a function you map a
> function name and that would mean N.  Besides you would lose the ability to map
> a constructed function name ie "c" though that is something you would seldom
> need I guess.

And it would be covered by applying a suitable \exp_args:... to the 
..._map_function:... call, would it not?

> If you map several tokens then this means that you either have a bunch of
> static tokens plus a final token/function that picks up the argument. Or
> alternatively you map a function with several arguments (and only the last one
> is filled with items from the sequence)

This is what /I/ would expect to use such a feature for. In some circles, 
it's called currying: construct an n-k arguments function from an n 
arguments function by passing it with the first k arguments already supplied.

> or it is a mixture of both. None of
> those scenarios feel right to me. From a programming aspect I would probably
> always prefer to define my mapping function properly first and then apply it,
> ie instead of
>
>   ...map_function:Nn \l_foo_seq {<some tokens>  \func:n }
>
> I would rather do
>
>   \cs_new:Npn \map_func:n #1 {<some tokens>  \func:n #1}
>
>   ...map_function:NN \l_foo_seq \map_func:n

And instead of

   ...map_function:Nn \l_foo_seq { \func:nn{foo} }

rather do

   \cs_new:Npn \map_func:n #1 { \func:nn{foo}{#1} }

   ...map_function:NN \l_foo_seq \map_func:n

? The downside of this is that it hardwires the "foo" into a function 
body, when in practice it might be data that changes from call to call. 
You can of course redefine \map_func:n before every use, but it feels 
unelegant.

> This has to be done anyway if the #1 needs to be somewhere other than at the
> end, eg
>
>   \cs_new:Npn \map_func:n #1 {\func:nnn {foo}{#1}{bar}}

Not at all! In that case, you do

   \cs_new:Npn \exch_args:Nnnn #1 #2 #3 #4 { #1{#2}{#4}{#3} }

   ...map_function:Nn \l_foo_seq { \exch_args:Nnnn\func:nnn{foo}{bar} }

(the stem "exch" is of course from the postscript operator which exchanges 
the top two operands on the stack) or possibly

   \cs_new:Npn \exchd_func:nnn #1 #2 #3 { \func:nnn{#1}{#3}{#2} }

   ...map_function:Nn \l_foo_seq { \exchd_func:nnn{foo}{bar} }

but \exch_args:Nnnn is more elegant, since it can be reused in more places.


Lars Hellström