Como permitir parâmetros inteiros e numéricos mistos no icase

De acordo com o link:

https://www.postgresql.org/docs/current/xfunc-sql.html#XFUNC-SQL-POLYMORPHIC-FUNCTIONS

Com make_array declarado como acima, você deve fornecer dois argumentos que sejam exatamente do mesmo tipo de dados; o sistema não tentará resolver nenhuma diferença de tipo.

Uma abordagem alternativa é usar a família “comum” de tipos polimórficos, que permite ao sistema tentar identificar um tipo comum adequado.

Então:

CREATE OR REPLACE FUNCTION public.icase(cond1 boolean, res1 anycompatible, cond2 boolean, res2 anycompatible, conddefault anycompatible)
 RETURNS anycompatible
 LANGUAGE sql
 IMMUTABLE
AS $function$ 
SELECT CASE WHEN $1 THEN $2 WHEN $3 THEN $4 ELSE $5 END; 
$function$
;

Que quando executado faz:

select icase(false, 0, false, 0.,0.);                                                                               
 
icase 
-------
     0


select icase(false, 0, false, 0.,0.0);
 
icase 
-------
   0.0

Embora, como você pode ver, isso forçará a saída para um tipo comum adequado.

Como permitir parâmetros mistos integernumeric

Tipos polimórficos levam a um tipo de dados comum e uniforme. Anyelementatuará como um espaço reservado para 4x o mesmo tipo e, se você passar 3 coisas diferentes (a quarta é o tipo de resultado que será ajustado para os 3 parâmetros), ele simplesmente desistirá .

Anycompatiblenão desistirá, mas tentará converter as 3 coisas diferentes para um tipo comum, se for possível, e somente se houver apenas uma maneira única de converter todas elas. Ele permitirá que você invoque a rotina usando uma mistura de tipos, mas todos eles acabarão convertidos .

Sobrecarregue sua função se quiser mais controle (e planeja permanecer na v12):
_{demonstração em db<>fiddle}

CREATE OR REPLACE FUNCTION public.icase(--inn
   bool,int,bool,numeric,numeric)    
RETURNS numeric IMMUTABLE AS $body$
SELECT CASE WHEN $1 THEN $2 
            WHEN $3 THEN $4 
            ELSE $5 
       END 
$body$ LANGUAGE sql;

CREATE OR REPLACE FUNCTION public.icase(--nin
   bool,numeric,bool,int,numeric)    
RETURNS numeric IMMUTABLE AS $body$
SELECT CASE WHEN $1 THEN $2 
            WHEN $3 THEN $4 
            ELSE $5 
       END 
$body$ LANGUAGE sql;

CREATE OR REPLACE FUNCTION public.icase(--iin
   bool,int,bool,int,numeric)    
RETURNS numeric IMMUTABLE AS $body$
SELECT CASE WHEN $1 THEN $2 
            WHEN $3 THEN $4 
            ELSE $5 
       END 
$body$ LANGUAGE sql;

CREATE OR REPLACE FUNCTION public.icase(--nnn
   bool,numeric,bool,numeric,numeric)    
RETURNS numeric IMMUTABLE AS $body$
SELECT CASE WHEN $1 THEN $2 
            WHEN $3 THEN $4 
            ELSE $5 
       END 
$body$ LANGUAGE sql;

CREATE OR REPLACE FUNCTION public.icase(--iii
   bool,int,bool,int,int)    
RETURNS int IMMUTABLE AS $body$
SELECT CASE WHEN $1 THEN $2 
            WHEN $3 THEN $4 
            ELSE $5 
       END 
$body$ LANGUAGE sql;

Com as 5 definições acima, qualquer uma das 8 combinações possíveis de inte numericem qualquer uma das 3 posições é resolvida corretamente:

Se você quisesse misturar tipos de parâmetros entre diferentes chamadas, não dentro de uma única invocação, sua definição já funcionaria, desde que você usasse conversões de tipo explícitas e uniformes:
_{demo em db<>fiddle}

select icase(false, 0::numeric,false, 0.::numeric,0.::numeric);
select icase(false, 0::float4, false, 0.::float4, 0.::float4);
select icase(false, 0::float8, false, 0.::float8, 0.::float8);
select icase(false, 0::int2,   false, 0.::int2,   0.::int2);
select icase(false, 0::int4,   false, 0.::int4,   0.::int4);
select icase(false, 0::int8,   false, 0.::int8,   0.::int8);