Fish: A user-friendly command line shell for macOS, Linux, etc

I implore you to NOT use JSON or ProtocolBuffers, neither are appropriate formats for configuring my shell, or storing long sets of textual data. Protocol Buffers is hardly the kind of format I want to parse and read my history in, and JSON is a less than ideal configuration format for many reasons.

https://github.com/vstakhov/libucl UCL (Universal Configuration Language) is a much more appropriate format for configuring programs than JSON, and is has been accepted as standard for use configuring all tools included in the FreeBSD operating system.

I also suggest you consider using a different language to store shell history, since shell history and shell configuration are two very different jobs with different goals and trade offs. I personally would suggest a simple safe format like TOML https://github.com/toml-lang/toml for storing the history.

But If you do want a single format for both configuration and history, I would implore you to pick TOML not JSON or Protocol Buffers.

Thank you for leading the charge on modern command line design.

[0] https://fishshell.com/docs/current/design.html

[1] https://www.pgcli.com

[2] https://www.mycli.net

That and support for

    SOME_ENV_VAR=foo ./bar

Btw: Big thank you for fish, it's awesome!

With ZSH, I can run a command with a space at the start so it's excluded from history, even though its not saved to disk, the last command is still stored in memory so I can press Up to access it again.

This is handy when a mistake is made in the command means I need to run it again with some small change.

Maybe adopt a package manager for plugins too? ;)

[0] https://github.com/psprint/zsh-navigation-tools

1. equivalent of `set +x` and `set +e` from bash (to echo commands and stop script execution on the first non-zero return) – https://github.com/fish-shell/fish-shell/issues/3427,

2. Associative arrays – https://github.com/fish-shell/fish-shell/issues/390

What I don't like is that after hitting Tab twice when doing path completion, the list of possibilities comes out, allowing arrow keys to be used for selection. The problem is that it requires pressing Enter to confirm the suggestion and I fear of executing the command with incomplete path prematurely (it's just one more Enter hit away).

Other than that, my biggest pain point with fish now is that it doesn't interact well with pkg-config (issue #982) and the workarounds for that are a bit awkward. eval is scary and may require double-quoting the non-pkg-config parameters, and string splitting can wrongly split inside quoted text.

This. It's an awesome shell, but I couldn't set is as a default because my already done shellscripts and aliases would stop working. And I also can't set it on server, because then a deployment tool logs in, and expects bash.

And if it isn't default, I might not bother, I'd forget to run it manually most of the time.

(The worst offender is replacing && with 'and' - why not at least enable both and preserve compatibility?)

I’ve never had issues as a somewhat heavy user.

I will never install it on any remote system, because it doesn't feel right to force a shell to other remote users.

Also how much time do you need something that fancy on a remote prompt? The nice features of bash like [Ctrl-r] works everywhere and the shortcuts ( Ctrl-a, etc. ) are usually the same.

The power that zsh gives me is all about my local dev machine. Things like utilities command completion or `scp remote-server:~/ [tab]` to find a file on a remote machine, or the countless other extras are mostly useful on my local.

I use fish interactively and write very simple scripts in bash and the more complex in Python.

https://github.com/robbyrussell/oh-my-zsh

You need to learn a few idioms like: replace $[1+1] with (math "1+1"); replace

> for f in $(ls); do echo $f; done

with

> for f in (ls); echo $f; end

I should start a Rosetta Stone of Bashisms to Fishisms - I'd be interested if anyone has got Android Open Source build environment / lunch working.

http://www.oilshell.org/blog/

If nothing else, I have thousands of lines of my own shell scripts that I don't care to move to a different shell syntax that's not obviously better :)

There are lots of posts on the blog about it, but here is an example:

"OSH Runs Real Shell Programs" - http://www.oilshell.org/blog/2017/07/02.html

Another comment: https://news.ycombinator.com/item?id=15916470

However one thing is that it's not yet a good interactive shell. It's mainly treating bash as a programming language. However I think that is a good foundation for an interactive shell. Some details here:

https://www.reddit.com/r/commandline/comments/7c3f9f/osh_02_...

"\e[A": history-search-backward # Up key

"\e[B": history-search-forward # Down key.

Allows you to get press up while you have `ssh 10.2` in the terminal to cycle through ips matching, etc. It won't display like in fish before pressing it, but I find that's a reasonable tradeoff.

[1] https://github.com/edc/bass

Happily the begin/ends in ifs are no longer necessary:

   if not command test -f $dest
      or command test $src -nt $dest
     # stuff
   end

    if command [ ! -f $dest -o $src -nt $dest ]
       #stuff
    end

What I ended up with was (for a shortcut for generating a password on the command line):

    function pw --argument length
        test -z $length; and set length 16
        python3.6 -c "import secrets; print(secrets.token_urlsafe($length))"
    end

    not command test -f $dest
    if or command test $src -nt $dest
        # do something
    end

I also use it on my home computer (on top of zsh) and am pretty happy with it.

It is a bit slower in terms of response time, but that's OK. Most of the problems I had with it have been resolved after filing bug reports. The only annoyance is that when I quit Midnight Commander, I'm back in the directory I started with. But that's a MC problem, and not xonsh. Every shell out there has a special wrapper script to handle MC. I just need to understand the one zsh uses and port it over to xonsh.

The two best parts about xonsh:

1. You can use the command line like you would a Python interpreter. Need to do a quick calculation? Just type it in and press Enter.

2. No more obnoxious bash/zsh scripting. Write all your shell scripts in Python!

Like fish, it'll interpret an unquoted asterisk (sorry HN formatting) as the glob character. So it tries to match pathnames to `host:directory/`.

Only the default bash behavior (if "nullglob" and "failglob" aren't set) is to pass the literal glob expression if no match could be found.

So once you `mkdir host:directory; touch host:directory/file` (which you can do - this is unix, so almost all pathnames are allowed), this will be broken.

This means you _should quote the token_ in bash, which is exactly what you should do in fish.

Note: This is also why you might see code like the following in bash:

    for file in *; do
        if test -e "$file"

But of course having to recall how to do something in a POSIX-compatible shell can cost if you've been using a POSIX-incompatible shell for years. Memory and experience do fade over time.

We have that feature, and it's enabled by default. Just type the partial commandline and press up-arrow. Or do you mean something slightly different?

Note that functions already don't expand the passed arguments. Fish expands them _before_ executing the function, so what you are asking for is a major layering violation.

E.g. you can do this:

    function a
       b $argv
    end

    function b
       string escape -- $argv
    end

    a 'something * with ? loads {} of $pecial char"acters'

>This would enable us to pass e.g. URLs to a function without quote them

I'm assuming what you are asking for isn't _passing_ URLs to functions, but rather _pasting_ URLs into the commandline.

In which case fish has a feature I like to call "magic paste". When you paste with an open single quote (`somecommand '`), it'll escape single quotes (and backslashes). So you type the closing single quote and your argument will be passed to the command you are calling as the exact text you pasted.

>The key should be displayed and if the user selects a completion-item, the corresponding value should be passed to a fish-function from which arbitrary actions could be triggered.

We have "descriptions" for completions, which will be displayed _alongside_ the argument (i.e. the "value"). To generate them dynamically, simply separate them with a tab character (`\t`) from the argument, and separate these pairs with newlines.

So

    printf '%s\t%s\n' 'argument' 'description' 'argument2' 'description2'

    argument (description)    argument2 (description2)

    0a129475    (Replace opts.stdout with opts.to_stdout)

>Maybe supporting JSON input here would be nice too.

The best completions are those that actually call the stuff they are completing (because that makes them really reactive), and not many commandline tools actually generate JSON. Anything in particular you're thinking about here?

(And now I'm hoping that HN doesn't hopelessly mangle this comment)

    set BROWSER lynx
    help

Since I use the non-graphical Emacs (emacs-nox), I can easily start dired-mode in terminal by writing: emacs .

Fish is almost zero configuration and has many useful functions built-in and they are quite fast. Unfortunatelly it doesn't use bash-style syntax like zsh does.

https://github.com/oilshell/oil/wiki/ExternalResources

Of course I think my own project, Oil, could be a "21st century shell", or I wouldn't be working on it :) It's designed in a principled way, and it's also the only one that's compatible with bash.

[1] https://github.com/railsware/upterm