How can the scope of jq 'as' variables be extended to pass down inside functions? - scope

Question

With jq, I'm trying to use entries in one array to index into a separate array. A simple JSON input would look like this:
{
"myArray": [ "AA", "BB", "CC", "DD", "EE" ],
"myFlags": [ 4, 3, 2, 1, 0 ]
}
jq's nifty 'as' operator is then able to bring the myArray array into scope and the indexing works fine:
.myArray as $Array | .myFlags | .[] | $Array[.] ====> yields "EE","DD","CC","BB","AA"
So far so jq-manual. However, if I try and move the $Array array access down into a function, the as-variable scope disappears:
def myFun: $Array[.]; .myArray as $Array | .myFlags | .[] | myFun
jq: error: $Array is not defined at <top-level>, line 1:
def myFun: $Array[.]; .myArray as $Array | .myFlags | .[] | myFun
To get around this, I currently pass down a temporary JSON object containing both the index and the array:
def myFun: .a[.b]; .myArray as $Array | .myFlags | .[] | { a: $Array, b: . } | myFun
Though this works, I have to say I'm not hugely comfortable with it.
Really, this doesn't feel to me as though this is proper jq language behaviour. It seems to me that the 'as'-scope ought to persist down into invoked def-functions. :-(
Is there a better way of extending as-scope down into def-functions? Am I missing some jq subtlety?

Answer 1

It actually is possible to make an "as" variable visible inside a function without passing it in as a parameter (see "Lexical Scoping" below), but it is usually unnecessary, and in fact using "as" variables is often unnecessary as well.
Avoiding the "as" variable
You can simplify your original query to:
.myArray[.myFlags[]]
Using function arguments
You can write jq functions with one or more arguments. This is the appropriate way to parameterize filters.
The syntax is quite conventional except that for functions with more than one argument, the semicolon (";") is used as the argument separator, both in the function definitions and invocations.
Note also that jq function arguments can themselves be filters, e.g. you could write:
def myFun(array; $ix): array | .[$ix];
myFun(.myArray; .myFlags[])
Lexical scoping
Here's an example showing how an 'as' variable can be made visible inside a function:
[1,2] as $array | def myFun: $array[1]; myFun