Devolver [] guardado en DownValues

Question

Ejemplo:

f[x_] := f[x] = (If[x < 0, Return[x]]; x)
f[1];
f[-5];
DownValues[f][[1 ;; 2]]

(* {HoldPattern[f[-5]] :> Return[-5], HoldPattern[f[1]] :> 1} *)

Quiero que guarde el valor que se devuelve, sin el Return[]. En caso de que importe, la función real se parece a esto:

f[list_,n_] := f[list,n] = Block[{li = list, moreVars},
    Which[
        n == 0, Return@li,
        li[[i1]] > 0, li[[i1]]--,
        li[[i2]] > 0, li[[i2]]--,
        True, Return@li
    ];
    f[li, n - If[bla, 2, 1]]
]

Answer 1

No es muy elegante, pero podría usar un reemplazo:

f[x_] := f[x] = (If[x < 0, Return[x]]; x) /. Return[z_] :> z
f[1]; f[-5];
DownValues[f][[1 ;; 2]]

{HoldPattern[f[-5]] :> -5, HoldPattern[f[1]] :> 1}

Alternativamente, quizás podría deshacerse de él por Returncompleto. Por ejemplo,

f[list_, n_] := f[list, n] =
  Block[{li = list, moreVars},
   Which[
    n == 0,
        li,
    li[[i1]] > 0,
        li[[i1]]--;
        f[li, n - If[bla, 2, 1]],
    li[[i2]] > 0,
        li[[i2]]--;
        f[li, n - If[bla, 2, 1]],
    True,
        li]
   ]

o en un enfoque más funcional

f[list_, n_] /; n == 0 := f[list, n] = list;

f[list_, n_] /; list[[i1]] > 0 := f[list, n] = 
   Block[{li = list, moreVars},
    li[[i1]]--;
    f[li, n - If[bla, 2, 1]]
    ];

f[list_, n_] /; list[[i2]] > 0 := f[list, n] = 
   Block[{li = list, moreVars},
    li[[i2]]--;
    f[li, n - If[bla, 2, 1]]
    ];

f[list_, n_] := f[list, n] = list;

Answer 2

Podría usar la versión de dos argumentos de Return:

Clear[f]

f[x_] := f[x] = (If[x<0, Return[x, CompoundExpression]];x)
f[1];
f[-5];
DownValues[f][[1;;2]]

{HoldPattern [f [-5]]:> -5, HoldPattern [f [1]]:> 1}

El problema con un argumento único Returnes que se deben usar heurísticas para determinar de qué construcción se devuelve.

Answer 3

En este caso, creo Throwy Catchprobablemente mejores construcciones para lo que quieres hacer:

f[list_,n_] := f[list,n] = Catch @ Block[{li = list, moreVars},
    Which[
        n == 0, Throw[li],
        li[[i1]] > 0, li[[i1]]--,
        li[[i2]] > 0, li[[i2]]--,
        True, Throw[li]
    ];
    f[li, n - If[bla, 2, 1]]
]

Esto le da un control mucho mejor sobre el flujo del programa que Return.