Am 22.07.21 um 18:42 schrieb Sven Schreiber: Usually I like the idea of having a minimum number of arguments to pass to a function. But I am not sure in this case. Currently, the signature of replace() is: replace(x, find, subst) This is a very intuitive and hence an easy to remember signature. Introducing an alternatively supported signature for _the_ _same_ function of the kind replace(x, {find, subst}) where {find, subst} acts like a set, I find disturbing. I guess the "Zen" would say "There should be one-- and preferably only one --obvious way to do it." :-D It adds an additional layer to the function (the cost) for a very limited benefit (having two instead of three arguments). Ok, this already works according to the doc as find and subst can be vectors. True, strsub() has similarities to replace(). Having two functions doing a similar thing are a kind of "historical costs" every software has I guess ;-) Some more words on this even though this is drifting away a bit (sorry for that): -------------------------------------- This reminds me of some thought I had a couple of weeks ago: Having an apply() function which executes a function "element-wise". An element could be a row, column or an item in some array. Thus, one may say <hansl> strings input = defarray("A", "B", "C") strings find = defarray("A", "B", "C") strings subst = defarray("D", "E", "F") apply(strsub(input, find, subst)) </hansl> The apply function "knows" that it has to run through each element of the string-array and execute "element-wise" the strsub() function. This may be useful for the following reasons: 1. Calling apply() may be a hint for gretl that the separate steps are independent such that things can be parallelized (pretty sure this does not always hold). 2. This may make it easier to add support for array-like data for functions which currently do not support arrays such as strsub(), meanc() (in a matrix array). Thus, at least I imagine, one does not need to touch the C code of each separate function but rather one has an abstract function apply() which makes sure that a function is applied element-wise. For instance, take the strsplit() function for which Allin added support for string-arrays a couple of weeks ago. For strsub() Allin did not so. I guess because there was no need for it, yet, and of course(!) this involves a lot of additional work. In principle, this is similar to Pandas's apply function: https://pandas.pydata.org/pandas-docs/stable/reference/api/pandas.DataFra... Each string is mapped to some identifier value. Changing the identifier values (integers), requires running stringify() again. <hansl> clear nulldata 3 strings S = defarray("A", "B", "C") series y = seq(1,3)' stringify(y, S) print y -o x = replace(y, 1, 2) print y x -o stringify(x, S) print y x -o </hansl> Artur

Am 23.07.2021 um 15:54 schrieb Riccardo (Jack) Lucchetti: Yes, interesting thought, and would in principle avoid touching many function implementations that otherwise could be generalized to arrays and such. Of course, feval() also comes to mind here. Maybe it could be cleverly generalized to achieve the same thing? E.g., overloading it by taking a modern option bundle, with members "arg1", "arg2", and other directives? (But this is not thought through yet, just a spontaneous thought.) thanks sven