Tip: hierarchical lists are easier than you think

[alurm]

I'll start with an extract from https://wryun.github.io/es-shell/paper.html:

This example shows rich return values being used to implement hierarchical lists:

fn cons a d { return @ f { $f $a $d } }
fn car p { $p @ a d { return $a } }
fn cdr p { $p @ a d { return $d } }

The first function, cons, returns a function which takes as its argument another function to run on the parameters a and d. car and cdr each invoke the kind of function returned by cons, supplying as the argument a function which returns the first or second parameter, respectively. For example:

es> echo <>{car <>{cdr <>{cons 1 <>{cons 2 <>{cons 3 nil}}}}}
2

Turns out there is a much simpler solution:

fn list { return @ _ { return $* } }

example-list = <={ list a b c }

# Append.
example-list = <= { list <=$example-list d e f }

printf '%s\n' <=$example-list

Not sure if there's anything actionable that can be done about this (except for maybe mentioning this in the documentation), so I opened a discussion instead of an issue.

[alurm]

Here's a case where I found this to be useful:

# For the lack of hierarchical lists in es.
# Stores the list in a closure and returns it when called.
fn list { return @ _ { return $* } }

fn split-by-double-dash {
	let (
		args = <={ list $* }
		rest = <={ list }
		indicies = `{ seq $#* }
	) {
		for (i = $indicies) if { ~ $*($i) -- } {
			args = <= {
				if { ~ $i 1 } { list } {
					list $*(... `{ expr $i - 1 })
				}
			}
			rest = <= {
				list $*(`{expr $i + 1} ...)
			}
			break
		}
		return $args $rest
	}
}

(args rest) = <={ split-by-double-dash a b c -- d e f }

printf '%s\n' <=$args
printf '%s\n' <=$rest

[jpco]

Yes! This came up many moons ago in the mailing list (though after the paper was written) and it was nearly added to es, but they never quite did so.

It's a little wonky, but could be quite useful. I would very much appreciate to see more cases where people make use of this in a practical way, or even better, a hacked up initial.es where someone tried integrating this into the shell more deeply. This is definitely a possibility for the shell that hasn't been explored enough.