La diferencia es el "viceversa": any puede fluir hacia otros tipos pero mixed no pueden.

 /* @flow */ var numeric:number = 0; var anyTyped:any; var mixTyped:mixed; numeric = anyTyped; numeric = mixTyped; // This will throw a flow check error: "Cannot assign `mixTyped` to `numeric` because mixed is incompatible with number. [incompatible-type]"

De los documentos a los que se vinculó:

Vale la pena señalar cualquiera específicamente debido a la naturaleza especial de esta anotación. Use cualquiera para escapar de la tipificación estática de Flujo. En otras palabras, si Flow se interpone en su camino y está absolutamente convencido de que su programa tiene el tipo correcto, puede silenciar los errores anotando ubicaciones a lo largo de las rutas de error con type any.

"Cualquiera" admite covarianza y contravarianza. Eso es porque "cualquiera" es un supertipo y un subtipo de todos los tipos.

Por lo tanto, esto funciona,

 let genericVariable: any = 20; let numericVariable: number; genericVariable = numericVariable; // No error numericVariable = genericVariable; // No error

mixto admite covarianza solamente. Es un supertipo y no un subtipo de todos los tipos.

 let genericVariable: mixed = 20; let numericVariable: number; numericVariable = genericVariable; // This shows error genericVariable = numericVariable; // This works fine.

Covarianza: el tipo genérico (padre) podría sustituirse por un tipo especial (hijo)

Contravarianza: el tipo especial (hijo) podría sustituirse por el tipo genérico (padre). Esto es un problema, a menos que esté protegido por ciertas convenciones.

Cuando el flujo ve any , eso significa que puede usar cualquier tipo. El programa es indiferente al tipo de parámetro y no intentará inferir el tipo de resultado. Entonces, el tipo de resultado también será any .

Por ejemplo, el siguiente código no reportará ningún error:

 // @flow function add(one: any, two: any): number { return one + two; } add(1, 2); // Works. add("1", "2"); // Works. add({}, []); // Works.

Pero el tipo "mixto" debe procesarse de alguna manera para inferir el tipo real.

 // @flow function stringify(value: mixed) { // $ExpectError return "" + value; // Error! } stringify("foo");

En su lugar, debe asegurarse de que el valor sea de cierto tipo refinándolo.

 // @flow function stringify(value: mixed) { if (typeof value === 'string') { return "" + value; // Works! } else { return ""; } } stringify("foo");