I think it is a good change to remove auto-globbing from variables and string interpolations. Also agreed that we can get rid of str glob-escape.

I'm just not sold on adding --glob to glob-capable builtin commands because it seems like a limited solution that does not solve the problem in all cases where globs can occur:

First, custom commands:

> def gcmd [g: glob] { open $g }
> 'a' > a.txt
> 'b' > b.txt
> gcmd *.txt 
# opens a.txt and b.txt
> let g = '*.txt'
> gcmd $g  # <-- How to expand the glob here?

Note: gcmd *.txt doesn't work on this PR but works on main, I think it's a bug in this PR.

Second, externals. Currently, we do expand globs for externals:

> mkdir cliargs
> cd cliargs
> cargo init
> 'fn main() {
    println!("{:?}", std::env::args().collect::<Vec<String>>());
}' o> src/main.rs
> let gl = '*'
> cargo run -- $gl
["/home/kubouch/.cargo/target/debug/cliargs", ".git", ".gitignore", "Cargo.lock", "Cargo.toml", "src"]

If we remove the variable/string interp. auto-globbing (which we should), there would be no way to allow it for externals because we can't add a --glob flag there.

Third, plugins? Any other cases?

I am thinking of three alternatives (not mutually exclusive):

1. Add a new Value::Glob variant which could be passed around and cast to/from string (into string, into glob) to prevent glob expansion or collected into a list if needed. Example:

> let g: glob = 'a*c.txt'
> rm $g  # removes abc.txt, azc.txt, ...
> rm a*c.txt   # same
> rm ($g | into string) # removes only a*c.txt
> rm 'a*c.txt' # same
> external-command $g # passes [abc.txt, azc.txt, ...] to the external
> external-command ($g | into string) # passes only [a*c.txt] to the external

2. Not adding a new value type, but rely more heavily on the spread operator:

> let g: string = 'a*c.txt'
> rm ...(glob $g)  # removes abc.txt, azc.txt, ...
> rm a*c.txt   # same
> rm $g # removes only a*c.txt
> rm 'a*c.txt' # same
> external-command ...(glob $g)  # passes [abc.txt, azc.txt, ...] to the external
> external-command $g  # passes only [a*c.txt] to the external

3. Allow casting of lists to globs:

> def gcmd [g: glob] { open $g }
> let g = '*.txt'
> gcmd (glob $g)  # opens a.txt and b.txt

We have two other features related to globbing: Value::QuotedString and the glob command. So whatever we do, these should be kept in mind so that we don't duplicate functionality. In the option 1, for example, we might be able to remove both of them.

A much more radical approach to number 2 of @kubouch's comments above is to remove globbing from every command and only allow globs via the glob command and the used with the spread operator. It could cause people to lose their mind, but it would simplify things. (maybe remove it from all commands except ls?)

I'm up for giving most anything a try in order to get something nushell-y that we love.

1. Add a new Value::Glob variant which could be passed around and cast to/from string (into string, into glob) to prevent glob expansion or collected into a list if needed. Example:

We can fell into trouble if user uses rm with each command: ["a*b.txt", "acc.txt"] | each {|it| rm $it}. I think the type of $it is unclear. Maybe we need to make a decision to say $it is a string rather than glob?

Personally I like 2nd and 3rd solution :) Although I'm not sure how to make it works with ls and du commands, because they don't have rest parameter, then we can't use spread operator on these two commands

How does this perform with Kubouch's glob torture tests? BTW, I put it here so we can make changes to it easily https://hackmd.io/y5yMvEnrR7WTLH3vVBQlFg?edit

into glob sounds interesting. i'm looking forward to playing with it a bit.

I still fail into a trouble to play with the following two cases, given two files: touch a*c.txt abc.txt.

• for 1st one: to not apply a glob, we need to use into string inside foo: def foo [g: glob] { rm ($g | into string) }
  * for 2nd one: to apply a glob, we need to use into glob command: def foo [g: string] { rm ($g | into glob) }

Not really sure if the behavior is ok

Edit: the 2nd is resolved. There is only 1st issue left, but sadly I don't think there is a solution.

Reply to @kubouch 's proposal:

Add a new Value::Glob variant which could be passed around and cast to/from string (into string, into glob) to prevent glob expansion or collected into a list if needed.

Done :)

Not adding a new value type, but rely more heavily on the spread operator

Nushell supports this feature on most of filesystem command except ls and du. Because they don't accept rest parameters.

Allow casting of lists to globs: def gcmd [g: glob] { open $g }; let g = '*.txt'; gcmd (glob $g) # opens a.txt and b.txt

Currently this pr doesn't implement it. We can do this by let g: glob = "*.txt"; gcmd $g or let g = "*.txt"; gcmd ($g | into glob)

I think we can land and iterate through it

go for it, if you think it's ready.

let f: glob = "a*c.txt"; rm $f will remove a*c.txt and abc.txt

That's a fantastic solution to the problem, thanks!