First-Class commands/closures #18774

How are they higher order function?

each would correspond to map in a regular functional programming language, for example.

map is a function which takes in a list (or stream, depending on the language, but something list-shaped) and applies a function f to each element of a list.

Thus, for example, if f is a function like {|x| x+ 1}, then each f is a function which adds one to each element of a list-like thing

It's a function which takes another function, and returns something. (In this case another function, but thats besides the point)

If a function takes another function, it is called higher-order. Such a function (generally) indirectly calls its arguments inside its body, but doesnt necessarily represent calling a function either (It could, for example, store it inside a datastructure, or really anything else you would do with a regular value).

Also, how do you want it to look like without syntactic noise?

I'd prefer if the syntax for calling a closure directly was the same as calling any other command, and using a command as a closure could be more ergonomic.

I understand theres a lot more to consider here, but a proposal for the syntax could look like:

let f = {|x| x+ 1}
let myVar = 5
let myList = [1,2,3]
f myVar # Returns 6
$myList | each $f # Returns [2,3,4]

The slicing/currying syntax could look like:
(This is inspired by Purescript's placeholder syntax which I happen to like very much)

let f = _ - 1
let g = _ | encode base64
let h = $rm
let fList = [1,2,3]
let gList = ["a", "b", "c"]
let hList = [ "a.txt", "b.json", "c.csv" ]
$fList | each $f # Returns [2,3,4]
$gList | each $g # Encodes  each string in gList using base64
$hList | each $h # Deletes each file path in hList

Perhaps something like _... Could also be considered.

Point being, commands and closures would be identical in how theyre used.

Edit: Made some edit for consistency in the proposed syntax, with regards to slicing

Also a command and closure are fundamentally not the same thing.

Assuming commands are nushells analogue to functions, and closures to anonymous functions, they very much are in most functional languages, which I understand nushell is trying to be, or at least resemble.

Can you please correct your examples or specify how different you want them to behave, because apart from your probable typos, they work:

let f = {|x: int| $x + 1}
let myVar = 5
let myList = [1,2,3]
do $f $myVar # Returns 6
$myList | each $f # Returns [2,3,4]

let f = {|a| $a - 1}
let g = { encode base64 }
let h = {|a| rm $a }
let fList = [1,2,3]
let gList = ["a", "b", "c"]
let hList = [ "a.txt", "b.json", "c.csv" ]
$fList | each $f # Returns [2,3,4]
$gList | each $g # Encodes  each string in gList using base64
$hList | each $h # Deletes each file path in hList

If a function takes another function, it is called higher-order. Such a function (generally) indirectly calls its arguments inside its body, but doesnt necessarily represent calling a function either (It could, for example, store it inside a datastructure, or really anything else you would do with a regular value).

Commands are not first class citizens. They cannot take another command as input, but they can take closures. Closures are first class citizens.

I'd prefer if the syntax for calling a closure directly was the same as calling any other command, and using a command as a closure could be more ergonomic.

Here is the fun part, there is no "syntax" for calling a closure. There is none. All we do is provide closure to various builtin commands and they call it for us. This is where do command comes into play. The do command just passes its pipeline data and arguments to the closure and runs it.
So your provided example would look like this currently

let f = {|x| x + 1}
let myVar = 5
let myList = [1,2,3]
# you need to prepend $ sign to reference a variable
# myVar without $ sign is just a bare  string like "myVar", not a list
do $f $myVar # Returns 6
$myList | each $f # Returns [2,3,4]

The slicing/currying syntax could look like:
(This is inspired by Purescript's placeholder syntax which I happen to like very much)

let f = _ - 1
let g = _ | encode base64
let h = $rm
let fList = [1,2,3]
let gList = ["a", "b", "c"]
let hList = [ "a.txt", "b.json", "c.csv" ]
$fList | each $f # Returns [2,3,4]
$gList | each $g # Encodes  each string in gList using base64
$hList | each $h # Deletes each file path in hList

At this point you are just suggesting alternative syntax for closures, and the behaviour can already be achieved in nushell currently if you use the current syntax

let f = { $in + 1 }
let g = { encode base64 }
let h = { rm $in } # `rm` command doesnt take input from pipeline, you need to explicitly provide the argument
let fList = [1,2,3]
let gList = ["a", "b", "c"]
let hList = [ "a.txt", "b.json", "c.csv" ]
$fList | each $f # Returns [2,3,4]
$gList | each $g # Encodes  each string in gList using base64
$hList | each $h # Deletes each file path in hList

Edit: typos and also didn't realize @kuchta already responded

But that's probably main point of this issue, that commands are not first-class objects, which in my opinion they should, at least in functional languages, which i though nushell tries to be or at least favor such style. Functional languages ​​are named functional precisely because they have functions as first-class objects, i.e. they can be passed as parameters to other functions.