Hello,

Thanks for creating dune, I just tried it, and it's pretty fun.

If this package hypothetically were to be packaged for a Linux distro, what should the package name be?

dune is already taken by the build system for OCaml.

Would you prefer adam-mcdaniel-dune or something like dune-shell? Have you considered renaming the project to avoid name collisions?

Best regards, Alexander F. Rødseth

When using docker compose, every time I use the exec command e.g.

docker compose exec container_name

I get the following error:

unknown docker command: "compose builtin@exec"

It seems to me like the exec subcommand clashes with the builtin@exec 🤔

This is a rather big change, aiming to simplify parsing. Here's a summary:

• tokenizer.rs was refactored to use a struct containing a TokenKind instead of an enum. This makes it easier to match on the token's string content

• the tokenizer now also parses comments. This improves syntax highlighting.

• the tokenizer now also parses invalid characters. These are highlighted red.

• the parse_script function now tokenizes the input and removes all whitespace and comment tokens, and then proceeds with parsing. This improves the parser for several reasons:

  • no need to account for whitespace in the parser
  • no need to check if keywords or number literals are valid in the parser
  • robustness, separation of concerns
  • consistency: the syntax highlighter is guaranteed to have the same behaviour as the parser
  • no code duplication

• all parser functions in parser.rs now accept and return a new Tokens<'a> type, which is a wrapper for &'a [Token<'a>].

• usages of the tag parser have been replaced with a new text parser. That parser checks if the text in the next token matches the provided string. It doesn't check if the TokenKind is correct, but that is usually not necessary (for example, a token with the text "for" is guaranteed to be a keyword). Note that this was quite error-prone before, because tag("for") also parses the text "forager"

• to make sure that no invalid numbers are parsed (such as 1.05px, which is tokenized as FloatLiteral("1.05"), Symbol("px")), the parse_script function checks that "symbol-like" tokens can't appear directly after another without whitespace or punctuation in between.

  "symbol-like" tokens are number literals, bool literals, keywords, operators and symbols, because they can all contain the same characters.

• because the tokenizer parses comments, the comment crate was removed from dependencies

P.S. This also slightly changes how = is parsed: It is now nowhere required to put spaces around the = sign, so let foo={ bar=baz } works fine.

I tried exiting the shell after testing it using Ctrl-D and this didn't work. When I do something like echo "1 + 1" | dune I would expect to see "2" but I see the welcome screen of dune and it just hangs even without a prompt. Ctrl-C also doesnt work as expected then

Hello,

I'd like to redirect output to a file like:

curl https://loon.lib.utk.edu/scout-pdfs/MS.2271.pdf > MS_2271.pdf

Dune doesn't like this and ultimately I end up with something like this:

curl https://loon.lib.utk.edu/scout-pdfs/MS.2271.pdf > MS_2271.pdf
                            > 
syntax error:
 | on input `://loon.lib.utk.edu/scout-pdfs/MS.2271.pdf > MS_2271.pdf`
 | expected Eof

When starting Dune for the first time and typing ls, it works fine. However, after cd / I get this output when running ls:

(dune) /$ ls
thread 'main' panicked at 'called `Result::unwrap()` on an `Err` value: Io(Os { code: 13, kind: PermissionDenied, message: "Permission denied" })', src/bin.rs:440:48
note: run with `RUST_BACKTRACE=1` environment variable to display a backtrace

There are no permission issues when running this under zsh, it calls ls and lists the files normally.

This adds a new module parse, and implements a function json which parses a JSON value into a Dune expression. This allows users to interact with web APIs and build more complex dashboards like this one I made while messing around:

Adds parser benchmark using criterion. Run it with cargo bench.

On my computer, parsing the prelude takes about 450 ms. This is a lot, so I profiled with cargo-flamegraph. It seems that a lot of time is spent allocating strings.

I managed to reduce the parse time by 66% just by removing string allocations in SyntaxError::from_error_kind. However, this is currently not possible without making error messages less helpful.

The history file is created as ~/history.txt by default. It would be better, and more conventional, if it was stored as ie. ~/.dunesh_history, ~/.cache/dune/history.txt or $XDG_CACHE_DIR/dune/history.txt.

Makes chess-engine optional. It also disables default features of several dependencies to cut down compilation time. cargo run now only compiles 84 crates instead of 100.

It also adds Cargo.lock to git, which was previously ignored.

This PR introduces a significant speedup from reducing string allocations (pointed out by @Aloso in #43) in the parser by limiting the number of tokens converted to a string at once.

Bumps prettytable-rs from 0.8.0 to 0.10.0.

Dependabot will resolve any conflicts with this PR as long as you don't alter it yourself. You can also trigger a rebase manually by commenting @dependabot rebase.

hey, i've been meaning to do so for a while, but i haven't gotten around to it how can i add dune as a default shell? online guides say whatever shells are installed should have an entry in /etc/shells but dune's installed to my /home directory!! (i think) it's in /home/.cargo/bin and it works fine, would copying it as root to /bin and/or /usr/bin, then adding an entry for it to /etc/shells work?

There are already a lot of features that are very well explained through the README. I feel like the project would profit from a step-by-step guide through some of the most common scenarios:

• completion
• aliases (e.g. dc for docker compose)
• examples for integrating common developer tools like nvm, volta, rbenv, frum, zoxide, etc...

I would also like to offer my input on these topics but feel unable to write it myself as I don't really know that much about the shell.

EDIT: Maybe there could be a section detailing the differences between a posix-like shell and dune or even a table to compare implementations of different features in each shell.

Fixes #71. Closes #70.

This PR adds a variable to the environment that tracks whether the currently evaluated expression's output should be printed directly or stored in a string. This is done to allow things like let x = which vim or "[" + (hostname ()) + "]".

I also refactored some parts to clone objects less often, allocate fewer Boxes and Vecs and use .to_string() instead of format!("{}", ..) when possible.

I replaced occurrences of impl ToString with impl Into<String> or just String, because ToString uses the Display implementation which might be more expensive.

When I'm not connected to the internet, curl fails to get weather data which causes parse@json to fail, and also terminates the execution of my prelude early. I think that we should try to make a convenient way to handle errors (although the parsing functions should be implemented such that they return None instead of throwing errors).

I'm thinking of implementing a try builtin function that might behave like the following:

try 2 // 0 { echo "divide by zero"; 0 }

try would attempt to evaluate the first argument If it does not throw an error, then try will return that result. If the first argument fails to evaluate, it would evaluate the second argument, and return its result.