Como seleciono uma matriz para percorrer a partir de uma matriz de matrizes?

Você armazenará os nomesaoarrs dos arrays e dentro do corpo do select declarará um nameref para o nome escolhido :

ARGENT=("Nous devons économiser de l'argent."
"Je dois économiser de l'argent.")
BIENETRE=("Comment vas-tu?" "Tout va bien ?")
aoarrs=(ARGENT BIENETRE)

PS3='Which array? '
select arr in "${aoarrs[@]}"; do 
    [[ $arr ]] || continue
    declare -n ref=$arr
    for i in "${!ref[@]}"; do 
        printf '%d\t%s\n' $i "${ref[i]}"
    done 
    break
done

Correr pode parecer

1) ARGENT
2) BIENETRE
Which array? 3
Which array? 4
Which array? 5
Which array? 2
0   Comment vas-tu?
1   Tout va bien ?

Você gostaria de um mapeamento de "chaves" para "valores", onde "valores" são as listas de strings e as "chaves" são ARGENT, BIENETRE…

Você está no caminho certo aoarrs, porque poderia usar esse array como array associativo:

declare -A aoarrs
aoarrs[ARGENT]=$ARGENT
aoarrs[BIENETRE]=$BIENETRE

e então iterar sobre todas as chaves desse array usando algo como for key in ${!aoarrs[@]}….

Infelizmente , o bash não permite, por qualquer motivo, que listas sejam elementos dessas matrizes associativas.

Então, as coisas são péssimas. Você pode, por exemplo, juntar os elementos de suas listas com um caractere reservado para dividi-los mais tarde (isso é estúpido porque significa que você não pode ter todos os caracteres em sua string ou precisa começar a escapar deles), ou você pode construir suas próprias funções que pegam listas de strings, acrescentam-nas a um array grande e então você implementa sua própria função de pesquisa associativa nesse contêiner (isso seria estúpido; além de ser lento, também exigiria que você escrevesse relativamente muito código de uma forma relativamente linguagem inadequada). Seria terrível. Aqui está um exemplo que escrevo sem testá-lo, porque é feio o suficiente para que eu precise tirá-lo da cabeça, mas não quero mais lidar com isso:

#!/bin/bash
###############################
#        UNTESTED STUFF       #
# If you think this code is   #
# acceptable, consider doing  #
# something good for yourself #
# once in a while             #
###############################
declare -A index
declare -A lengths
declare -a storage

# Adds an entry to our our custom container
# 
# Usage:
# add_key_values KEY "list element 1" "list element 2" …
function add_key_values() {
  local key="$1"
  shift
  local -n valuelist=$@

  # get the length of the passed list, to save it
  local lengthlist=${#valuelist[@]}


  # get the end of the current storage, that's where we start adding
  # our list
  local start_index=${#storage[@]}

  # finally, actually store the list items in the storage
  for item in "${valuelist[@]}"; do
    storage+=("${item}")
  done
  lengths["${key}"]=$lengthlist
  index["${key}"]=$start_index
}

# Retrieve a list from the storage
# Sadly, bash is not a proper programming language, because what it calls
# "functions" don't do the one thing that a function needs to do:
# return a value for an argument. There's just no "return" mechanism in bash.
# 
# Returns an empty list if the key wasn't found.
#
# So, after sobbing a bit, we just say
# Usage:
# get_values $key
# Overwrites the `ret_val` variable with the list that was saved earlier
function get_values() {
  # prepare ret_val
  declare -g -a ret_val=()

  local key=$1

  # We return (with ret_val empty) if key isn't present
  # frigging bash doesn't have a "is key present in associative array" function…
  # so this is the workaround to check whether there's $key in $index.
  # seriously.
  local teststring
  teststring="$(printf 'index[%s]' "${key}")"
  # you need quite modern bash to even get the "is defined" -v test
  [[ -v "${teststring}" ]] || return

  # let's get all the elements from storage and append them to ret_val
  local start=${index[$key]}
  local length=${lengths[$key]}
  for idx in $(seq $(( start - 1 )) $((start - 1 + length)) ); do 
    ret_val+=("${storage[idx]}")
  done
}

####################
# EXAMPLE USAGE
####################
add_key_values "ARGENT" "Nous devons économiser de l'argent." "Je dois économiser de l'argent."
add_key_values "BIENETRE" ("Comment vas-tu?" "Tout va bien ?")

for key in ${!index[@]}; do
  echo "the list for value $key contains"
  get_values "${key}"
  for element in ${ret_val[@]}; do
    echo "element: ${element}"
  done
done

A próxima opção é mágica que envolve "endereçamento indireto" de variáveis ​​por nome usando eval. Isso é meio malvado e estúpido, e há muitos posts aqui que sugerem "se você está nesse ponto, talvez use uma linguagem de programação adequada em vez do bash".

Eu concordo com isso : todo esse problema seria literalmente feito em quatro linhas de python, com as duas primeiras linhas armazenando "ARGENT" e "BIENETRE" e suas listas em um arquivo dict. Ou, na verdade, em qualquer outra linguagem comum que não seja bash (ou C, nesse caso), matrizes associativas são menos ruins.

A matriz abrangente possui apenas nomes de variáveis:

aoarrs=(ARGENT BIENETRE)

while :; do
        select arr in "${aoarrs[@]}" quit; do
                declare -n ref=$arr
                case $arr in
                        quit)
                                break 2;; 
                        *)
                                select item in "${ref[@]}"; do
                                        echo $item
                                        break
                                done;;
                esac
                break
        done
done

declare -n ref=$arr- faça uma referência à variável nomeada pelo seu valor.
break 2- quebre 2 loops envolventes.

Seria mais fácil no ksh93 (o shell bash tenta emular), onde matrizes associativas podem ter matrizes (entre outras coisas) como valores.

#! /bin/ksh -

typeset -A all=(
  [argent]=(
    "Nous devons économiser de l'argent."
    "Je dois économiser de l'argent."
  )

  [bien-être]=(
    "Comment vas-tu?"
    "Tout va bien ?"
  )
)

select topic in "${!all[@]}"; do
  for sentence in "${all[$topic][@]}"; do
    print -r -- "$sentence"
  done
  break
done