mjhjmtu

In perl, a list context is mostly where an array variable is used (or could be used), simple.

In the shell, there are no array variables. However, the undefined list context description is sometimes used.

What is a practical list of list contexts examples ?

When should a list context term be used ?

The Perl comparison is not really helpful. That is a rigorously defined term in Perl, with specific meanings that affect how variables are treated in Perl. The term list context isn't an "official" thing in the shell world. It isn't mentioned anywhere in POSIX, for example. Note how the term is actually defined in most of the cases you point out where it is used: the very answer you link to (emphasis mine):

[. . .] on all words in list context (command line arguments or the words the for loops loop on)

(source)

There are two contexts in shell syntax: list context and string context. Field splitting and filename generation only happen in list context, but that's most of the time. Double quotes delimit a string context: the whole double-quoted string is a single string, not to be split.

(source)

So, essentially when you see the term "list context" with respect to a shell, this isn't an official term and is basically just used to mean "not explicitly a string", in other words, subject to split+glob and shell expansion.

POSIX does actually use list (not "list context"), but in two very different ways. It uses is as a specific, defined term to describe sets of commands (emphasis in the original):

2.9.3 Lists

An AND-OR list is a sequence of one or more pipelines separated by the operators "&&" and "||" .

A list is a sequence of one or more AND-OR lists separated by the
operators ';' and '&'.

The operators "&&" and "||" shall have equal precedence and shall be
evaluated with left associativity. For example, both of the following
commands write solely bar to standard output:

false && echo foo || echo bar 
true || echo foo && echo bar

A ';' separator or a ';' or terminator shall cause the
preceding AND-OR list to be executed sequentially; an '&' separator or
terminator shall cause asynchronous execution of the preceding AND-OR
list.

The term "compound-list" is derived from the grammar in Shell Grammar;
it is equivalent to a sequence of lists, separated by
characters, that can be preceded or followed by an arbitrary number of
characters.

However, the word list, since it is also the term used in everyday English to denote a set of items, is used quite often in the POSIX specs, usually to refer to lists of arguments. For example:

4. The shell performs various expansions (separately) on different parts of each command, resulting in a list of pathnames and fields to be treated as a command and arguments; see wordexp.

(Section 2.1)

If a simple command results in a command name and an optional list of arguments, the following actions shall be performed:

(Section 2.9.1)

The for loop shall execute a sequence of commands for each member in a list of items.

[. . .]

First, the list of words following in shall be expanded to generate a list of items.

(Section 2.9.4)

Returning to the top of the loop involves repeating the condition list of a while or until loop or performing the next assignment of a for loop, and re-executing the loop if appropriate.

continue builtin

All this is to say that when we refer to "list context" with respect to a shell, we are not using a strict, rigorously defined term such as Perl's, we're just referring to things the shell will treat as a list of items. Things that will be expanded, split, globbed etc. So, practically, any non-quoted collection of characters could be considered a list.

perl has no "list variables". perl has scalars, arrays, and hashes, and all of them could be used in a list or scalar context (with the void context as a special kind of scalar context). All subs (functions) in perl take lists as arguments and return lists. A list behaves differently from an array:

my @v = qw(a b c); my $v = @v; # $v will be 3

my @v = qw(a b c); my $v = @v[0..$#v]; # $v will be 'c'

This is all well documented in the perldata(1) manpage. The name of the operator which checks the type of the current context (wantarray) is simply a historical accident.

A bourne-like (POSIX) shell has nothing similar, so the question doesn't make much sense; are you wondering where an unquoted variable expansion is not subject to splitting with IFS and pathname expansion (globbing)? I can think of the right side of a=$var variable assignment, and the word and patterns of a case command: case $var in $pat) .... A comprehensive list will only be of interest to someone writing another shell implementation, and hopefully they won't base it on stackexchange answers ;-)