Spread Operator not properly spread in example

[AlOwain]

This is an issue, and not a pull request because I am new to Nushell and would like to confirm that this is in fact not proper behavior.

In Programming In Nu#Operators:262 (shown below)

foo "bar" "baz" ...[1 2 3]
# => [false, bar, baz, [1, 2, 3]]
foo "bar" "baz" [1 2 3]
# => [false, bar, baz, [[1, 2, 3]]]

The example (and many others in the same file) seem to indicate in the comments, that the default behavior of appending a list to another is that it is encapsulated as another list, and spreading it only appends the list as-is. My assumption would be that it wouldn't, and trying it out in the Shell seems to indicate so, for example:

~> ["bar" "baz" ...[1 2 3]] | to nuon
[bar, baz, 1, 2, 3]
~> ["bar" "baz" [1 2 3]] | to nuon
[bar, baz, [1, 2, 3]]

The absence of foo is intentional, as it does not change the demonstrability of the issue.

As a precursor, I had attempted to check for issues, or pull requests that mention this, it does not seem to have been addressed. The git blame result is a commit in the pull request #1692, which has many changes indicating that it could have just slipped by.

[ysthakur]

This is expected behavior.

The absence of foo is intentional, as it does not change the demonstrability of the issue.

You can't ignore it, actually. This is the definition of foo:

def foo [ --flag req opt? ...args ] { [$flag, $req, $opt, $args] | to nuon }

When you run foo "bar" "baz" ...[1 2 3], these are the arguments foo receives:

• No --flag, so that's set to false
• req gets "bar"
• opt gets "baz"
• args gets all of the rest arguments. Here, we spread [1 2 3], passing in 1, 2, and 3 in as rest arguments. These are then collected back into a list

So, when [$flag, $req, $opt, $args] in the body of foo is evaluated, $args is a single list. If you instead changed foo's body to [$flag, $req, $opt, ...$args] | to nuon, you would see a single flat list [false, bar, baz, 1, 2, 3] instead.

---

I do think that example could be better, though. We could have foo return a record instead:

def foo [ --flag req opt? ...args ] {
  { flag: $flag, req: $req, opt: $opt, args: $args } | to nuon
}

This would better demonstrate what happens to each argument:

> foo "bar" "baz" ...[1 2 3]
{flag: false, req: bar, opt: baz, args: [1, 2, 3]}
> foo "bar" "baz" [1 2 3]
{flag: false, req: bar, opt: baz, args: [[1, 2, 3]]}

If you like, you could open a pull request updating the documentation that way (don't forget to update the examples lower down too)

[AlOwain]

Ah, thank you very much. I apologize for the hassle, I overlooked it.

[AlOwain]

You are definitely right though, having it be a record makes it clearer, perhaps while reading the documentation, I'll try reviewing other examples for similar patterns, I'll try to avoid verbosity.

Finally, thank you very much, the documentation is superb, it's on me that I missed it.