A simple way to concat-and-assign (like `foo+=bar`)

[lloeki]

Manipulating string ins fish basically requires

A list of things that bash/zsh support that makes everyone life's easier and faster:

• concat adn assign operator: foo+="bar"
• pattern in string tests: [ $haystack = *needle* ] (not contains)
• prefix and suffix (longest and shortest) pattern matching and replacement (reference)

Those largely make calls to sed/grep/awk/basename/dirname useless, thus improving performance a lot in many cases, e.g #1325.

[lloeki]

Linked to #156 I guess.

[sugar700]

Concatenation already exists. Pattern matching as well, but it requires switch, which cannot be called intuitive (and it's a rather heavy structure).

set foo "$foo"bar

[lloeki]

That is not "concat_and_assign" though, so that gives unwieldy results for non-trivial variables and strings. I'd love to have a set -a foo "bar" to do exactly this (on a string to concat or an array to append a new item).

Compare and contrast this and this, or this and this.

The non repetition of the variable name makes it both more readable and easier to maintain (DRY and PEP8 "readability counts").

I think we can agree on abusing switch/case not being a good idea, especially that in the above linked scenarios it just doesn't work. We may have a solution in #156 for that, but I feel test should be on par with switch for consistency.

[sugar700]

If you want an append function, there is a sample one. It probably can be improved (for option parsing), but it already works. __fish_value is used, so people could append to value.

function append --no-scope-shadowing
    if test (count $argv) -ne 2
        echo append: Expected two arguments, (count $argv) received.
        return 1
    end
    set -l __fish_value $$argv[1]
    set $argv[1] "$__fish_value$argv[2]"
end

And example, just to show it really works.

xfix@pear ~> function append --no-scope-shadowing
                 if test (count $argv) -ne 2
                     echo append: Expected two arguments, (count $argv) received.
                     return 1
                 end
                 set -l __fish_value $$argv[1]
                 set $argv[1] "$__fish_value$argv[2]"
             end
xfix@pear ~> set test lol
xfix@pear ~> echo $test
lol
xfix@pear ~> append test fail
xfix@pear ~> echo $test
lolfail
xfix@pear ~>

I rarely saw a situation where append would be helpful, and in most cases, people implement complex scripts using other languages, such as AWK or Perl (but let's be honest, AWK doesn't have operator you want).

As for pattern matching, I think something like this can work.

function match
    if test (count $argv) -ne 2
        echo match: Expected two arguments, (count $argv) received.
        return 1
    end
    switch $argv[2]
        case $argv[1]
            return 0
    end
    return 1
end

Example, as always:

xfix@pear ~> function match
                 if test (count $argv) -ne 2
                     echo match: Expected two arguments, (count $argv) received.
                     return 1
                 end
                 switch $argv[2]
                     case $argv[1]
                         return 0
                 end
                 return 1
             end
xfix@pear ~> match '-*' --help; and echo Match.
Match.
xfix@pear ~> match '-*' help; and echo Match.
xfix@pear ~>

[lloeki]

Thanks. Both of those are great. --no-scope-shadowing will be quite useful to me in other cases.

Awk and perl are not useful when you're implementing a rich fish config and prompt, and for performance to be great you have to stay as much as possible in the shell, which pushes its scripting language to the limit. In unscientific tests with the above linked features, all advantages of fish in performance are lost to zsh and even bash solely due to the need to repeatedly call sed.

Allow me to veer a little out of topic. If fish had more 'fringe' features (in terms of the law of minimalism) like this, thus widely increasing the immediate usefulness of the language while only adding a very limited maintenance burden, I would readily use it much more to write scripts than perl or awk. Currently having a choice between bash (useful, piles of historical hacks) and perl/python/awk (more expressive, cleaner) makes me feel there's a need for something in between, and fish has all it takes to fill that void but those 'fringe' features that makes it feel like a minimalist but robust script language.

[leeola]

👍 for the string matching

[faho]

Everything here that's not concat-and-assign is in #156, so I'm renaming this.

[alphapapa]

Just to make it explicit, I'm requesting set -a/--append . :) e.g.

$ set food chicken
$ set -a food soup
$ for f in $food
      echo food: $f
  end
food: chicken
food: soup

[krader1961]

We're obviously never going to implement foo+=bar. Whether set --append foo bar (or set -a foo bar) is useful enough to justify the fact it is just syntactic sugar for set foo $foo bar is debatable. Also, what about prepending? Do we really need a set -p foo bar that is equivalent to set foo bar $foo? If not doesn't that argue for not adding an append flag?

I'm a big fan of the Zen of Python maxim that

There should be one-- and preferably only one --obvious way to do it.

[krader1961]

I intend to close this as will-not-implement in the near future unless someone can provide a better argument than is already present in this issue as to why we need --append and --prepend flags to the set command.

[krader1961]

Also, see issue #436 which proposes adding options for appending and prepending to variables.