IS DISTINCT FROM pode ser combinado com ANY ou ALL de alguma forma?

Olhando para ele como um problema de gramática, ANYé definido como (em comparações de linha e matriz ):

operador de expressão ANY (expressão de matriz)

Mas is distinct fromnão é um operador, é uma "construção" como nos é dito em Operadores de Comparação :

Quando esse comportamento não for adequado, use as construções IS [ NOT ] DISTINCT FROM

Como o PostgreSQL possui operadores definidos pelo usuário, podemos definir uma combinação operador/função para esse propósito:

create function is_distinct_from(text, text) returns bool as 
'select $1 is distinct from $2;' language sql;

create operator <!> (
 procedure=is_distinct_from(text,text),
 leftarg=text, rightarg=text
);

Então pode preceder ANY:

select count(*)
from (select 'A' foo union all select 'Z' union all select null) z
where foo <!> any(array[null, 'A']);  

contar
-------
     3
(1 linha)

Operador

Isso é baseado no operador inteligente de @Daniel .
Enquanto estiver nisso, crie a combinação função/operador usando tipos polimórficos . Então funciona para qualquer tipo - assim como a construção.
E faça a função IMMUTABLE.

CREATE FUNCTION is_distinct_from(anyelement, anyelement)
  RETURNS bool LANGUAGE sql IMMUTABLE AS 
'SELECT $1 IS DISTINCT FROM $2';

CREATE OPERATOR <!> (
  PROCEDURE = is_distinct_from(anyelement,anyelement),
  LEFTARG  = anyelement
, RIGHTARG = anyelement
);

Uma pesquisa rápida com o symbolhound não deu certo , então o operador <!>não parece estar em uso em nenhum dos módulos.

Se você for usar muito esse operador, poderá desenvolvê-lo um pouco mais para ajudar o planejador de consultas ( como losthorse sugerido em um comentário ). Para começar, você pode adicionar as cláusulas COMMUTATORe para auxiliar o otimizador de consulta. NEGATORSubstitua CREATE OPERATORde cima por isto:

CREATE OPERATOR <!> (
  PROCEDURE = is_distinct_from(anyelement,anyelement),
  LEFTARG  = anyelement
, RIGHTARG = anyelement
, COMMUTATOR = <!>
, NEGATOR = =!=
);

E adicione:

CREATE FUNCTION is_not_distinct_from(anyelement, anyelement)
  RETURNS bool LANGUAGE sql IMMUTABLE AS 
'SELECT $1 IS NOT DISTINCT FROM $2';

CREATE OPERATOR =!= (
  PROCEDURE = is_not_distinct_from(anyelement,anyelement),
  LEFTARG  = anyelement
, RIGHTARG = anyelement
, COMMUTATOR = =!=
, NEGATOR = <!>
);

Mas as cláusulas adicionais não ajudarão no caso de uso em questão e os índices simples ainda não serão usados. É muito mais sofisticado conseguir isso. (Não tentei.) Leia o capítulo "Informações de otimização do operador" no manual para obter detalhes.

Caso de teste

O caso de teste na questão só pode ser bem-sucedido se todos os valores na matriz forem idênticos. Para o array na pergunta ( '{null,A}'::text[]) o resultado é sempre TRUE. Isso é pretendido? Adicionei outro teste para "IS DISTINCT FROM ALL":

SELECT foo
     , foo <!> ANY ('{null,A}'::text[]) AS chk_any
     , foo <!> ALL ('{null,A}'::text[]) AS chk_all
FROM (
   VALUES ('A'),('Z'),(NULL)
   ) z(foo)

 foo | chk_any | chk_all
-----+---------+---------
 A   | t       | f
 Z   | t       | t
     | t       | f

Alternativa com operadores padrão

foo IS DISTINCT FROM ANY (test_arr) -- illegal syntax

quase pode ser traduzido para

foo = ALL (test_arr) IS NOT TRUE

foo = ALL (test_arr)rendimentos ...

TRUE .. se todos os elementos são foo
FALSE.. se algum NOT NULLelemento é <> foo
NULL .. se pelo menos um elemento IS NULLe nenhum elemento é<> foo

Portanto, o caso do canto restante é onde
- foo IS NULL
- e test_arr consiste em nada além de NULLelementos.

Se qualquer um deles puder ser descartado, estamos perdidos. Portanto, use o teste simples se
- a coluna estiver definida NOT NULL.
- ou você sabe que a matriz nunca é toda NULL.

Caso contrário, teste adicionalmente:

AND ('A' = ALL(test_arr) IS NOT NULL OR 
     'B' = ALL(test_arr) IS NOT NULL OR
     foo IS NOT NULL)

Onde 'A'e 'B'pode ser qualquer valor distinto. Explicação e alternativas nesta questão relacionada em SO:
É array todos os NULLs no PostgreSQL

Novamente, se você conhece algum valor que não pode existir em test_arr, por exemplo, a string vazia '', ainda pode simplificar:

AND ('' = ALL(test_arr) IS NOT NULL OR
     foo IS NOT NULL)

Aqui está uma matriz de teste completa para verificar todas as combinações:

SELECT foo, test_arr
     , foo = ALL(test_arr) IS NOT TRUE  AS test_simple
     , foo = ALL(test_arr) IS NOT TRUE
       AND ('A' = ALL(test_arr) IS NOT NULL OR
            'B' = ALL(test_arr) IS NOT NULL OR 
            foo IS NOT NULL)            AS test_sure 
FROM (
   VALUES ('A'),('Z'),(NULL)
   ) v(foo)
CROSS JOIN (
   VALUES ('{null,A}'::text[]),('{A,A}'),('{null,null}')
   ) t(test_arr)

 foo |  test_arr   | test_simple | test_sure
-----+-------------+-------------+-----------
 A   | {NULL,A}    | t           | t
 A   | {A,A}       | f           | f   -- only TRUE case
 A   | {NULL,NULL} | t           | t
 Z   | {NULL,A}    | t           | t
 Z   | {A,A}       | t           | t
 Z   | {NULL,NULL} | t           | t
     | {NULL,A}    | t           | t
     | {A,A}       | t           | t
     | {NULL,NULL} | t           | f   -- special case

Isso é um pouco mais detalhado do que a solução de AndriyEXCEPT , mas é substancialmente mais rápido.

Talvez assim :

select foo
     , exists (values (null), ('A') except select foo) chk_any
     , not exists (values (null), ('A') intersect select foo) chk_all
from ( values ('A'),('Z'),(null) ) z(foo);

 foo | chk_any | chk_all
-----+---------+---------
 A   | t       | f
 Z   | t       | t
     | t       | f

Observe que não apenas o nullin no "array", mas também o nullin zestá sendo comparado dessa maneira.