> A lot of the increase in line count can be explained by rustfmt’s formatting, as it likes to spread code out over multiple lines [...] The rest is additional features. Also note that our Rust code is in some places a straight translation of the C++, and fully idiomatic Rust might be shorter.

Since there are quite many contributors, it can be difficult to introduce some advanced macro requirements for the project, which could reduce the code.

Having to handle every case of every branch also probably balloons line count.

Efficient LOC is not a goal of rust at all anyway.

Also, here's a code size tracker that counts tokens not lines, which is a better measure: https://github.com/rrethy/tcount

I am no rust programmer though, and I don't think the rust code was very idiomatic.

But then again I apparently write c++ like a common lisp programmer...

Basically, the terminal will replace each line of the pasted text that match (start with)

  $ rest

  pbash 'rest_escaped'

  \$ 'rest_escaped'

This function will start (if not exists) a persistent background bash instance connected on both ends to FIFOs, with the same lifetime as your fish session. We then pass the `rest_escaped` to one FIFO, capture the output from the other FIFO, and echo it.

Because its a persistent session, stuff you copy that makes use of variables or bash aliases all Just Work. Being able to blindly copy-paste the entire bash codefence from a github readme.md is especially nice.

It all happens automatically after a one-time setup, and overall works pretty well for me. Here is a demo: https://i.imgur.com/HdqGkRk.png

This is the fish function

  function \$
      if not test -f /tmp/bash_daemon.pid; or not kill -0 (cat /tmp/bash_daemon.pid) 2>/dev/null
          echo "Starting bash daemon..."
          bash ~/scripts/bash_daemon.sh &
          sleep 0.5
      end
  
      echo "$argv" > /tmp/bash_daemon_pipe &
  
      while read -l line
          if test "$line" = "###DONE###"
              break
          end
  
          echo $line
      end < /tmp/bash_daemon_out
  end

  #! /usr/bin/env bash
  
  rm -f /tmp/bash_daemon_pipe /tmp/bash_daemon_out
  mkfifo /tmp/bash_daemon_pipe
  mkfifo /tmp/bash_daemon_out
  
  echo $$ > /tmp/bash_daemon.pid
  
  while true; do
      read cmd < /tmp/bash_daemon_pipe
      { eval "$cmd"; echo "###DONE###"; } > /tmp/bash_daemon_out
  done

Have you read Jef Raskin's The Humane Interface? It's an explainer and retrospective for his Canon Cat.

I want more of that foundation, vision, concept.

With the recent renewed interest textual user interfaces (TUIs), maybe this cycle we'll tact a little closer to that utopian future perfect omni-shell.

https://en.wikipedia.org/wiki/The_Humane_Interface

https://en.wikipedia.org/wiki/Canon_Cat

https://en.wikipedia.org/wiki/Jef_Raskin#Pioneering_the_info...

--

And another thing (I say curmudgeonly)...

bash (and csh), the progenator of all modern shells, is just one realization.

Iteration and refinement are double awesome. We're seeing crazy awesome new variants, like Warp.app, oil shell, fish, and so forth. Yea for evolution!

But I would also hope today's youngsters take a moment to review the genesis of all the modern ideas we now take for granted. From memory, in no particular order:

  Engelbart's Mother of All Demos
  Raskin's original vision for Macintosh
  Nelson's Xanadu
  Higgins art philosophy of "intermedia"
  Xerox PARC
  cybernetics
  Atkinson's HyperCard
  etc.

With 60+ years of progress and gestation, surely there are even more tangents worth exploring.

It's just that I never find myself needing to do anything fancy in the command line. I just want it to be fast, ergonomic, beautiful and unobtrusive.

And I wouldn't say it's because my workload is any simpler, I'm a relatively senior computer engineer working on large-scale data engineering, LLMs, non-trivial webdev and some systems programming in Rust. And it's not because I use UIs more often either, I use the command-line as much as anyone.

I guess that I have more of a "RISC" approach to the command-line.

I'll take the better syntax, thanks.

I'm not saying these are hard things, to figure out. I just agree that they're hard to remember when you don't use them all the time.

Apparently no one around here has a sense of humor, though, since my original post was heavily downvoted. I greatly prefer Rust over C++, but "rewrite it in Rust" has become kind of a meme. And if you can't laugh at yourself, who can you laugh at?