Covarianza e controvarianza (informatica)

In informatica, covarianza e controvarianza sono proprietà che caratterizzano alcuni operatori sui tipi. Un operatore è covariante se conserva la relazione di sottotipo, controvariante se la inverte. Prendono il nome dalle omonime proprietà dei funtori in teoria delle categorie.

Definizione

Un operatore F è covariante se F<T'> ≤ F<T> quando T' ≤ T. Analogamente, F è controvariante se F<T> ≤ F<T'> quando T' ≤ T.

Varianza e controvarianza sono caratteristiche degli operatori sui tipi che hanno uno o più parametri di tipo e producono un nuovo tipo. Non devono essere confuse con l'ereditarietà dei tipi in sé (es. non ha senso dire che un tipo è covariante o controvariante) o con la compatibilità tra tipi nell'assegnamento (es. in molti linguaggi a oggetti, un oggetto di un sottotipo è sempre assegnabile ad una variabile di un supertipo).

Esempi

Covarianza

Tipicamente, operatori che possono solo leggere oggetti del parametro di tipo possono essere covarianti. Ad esempio in C#, IEnumerable è covariante e un contenitore enumerabile di un sottotipo (es. IEnumerable<string>) può essere assegnato ad una variabile il cui tipo è un contenitore enumerabile di un suo supertipo (es. IEnumerable<object>). Questo perché i metodi di IEnumerable possono leggere oggetti dal contenitore ma non scriverli, quindi non c'è rischio di compiere operazioni non typesafe.

// Covarianza
IEnumerable<string> strings = new List<string>();
IEnumerable<object> objects = strings; // assegnamento valido

Controvarianza

Analogamente, operatori che possono solo scrivere oggetti del parametro possono essere controvarianti. Ad esempio in C#, template come Action<> sono controvarianti, in quanto un'azione definita ad esempio su un oggetto può essere eseguita su una stringa, ma non viceversa.

// Controvarianza
// assumendo che esista il metodo `static void SetObject(object o) { }'
Action<object> actObject = SetObject;
Action<string> actString = actObject; // assegnamento valido

Array e contenitori generici

Contenitori generici i cui elementi possono essere modificati sono intrinsecamente nonvarianti, e nei linguaggi in cui sono considerati covarianti questo può permettere operazioni non-typesafe che possono generare errori a runtime.

object[] array = new String[10];
array[0] = 10; // genera un'eccezione a runtime

Funzioni

Oggetti di tipo funzione sono tipicamente controvarianti negli argomenti e covarianti nei valori di ritorno, ovvero è typesafe sostituire una funzione S1 -> T1 con un'altra S2 -> T2 se essa accetta argomenti di un supertipo (S1 ≤ S2) e restituisce valori di un sottotipo (T2 ≤ T1).

$S_{1}\leq S_{2},\quad T_{2}\leq T_{1} \over S_{1}\rightarrow T_{1}\leq S_{2}\rightarrow T_{2}$

Tale regola è stata formalizzata da John C. Reynolds e resa popolare da un articolo di Luca Cardelli.

Alcuni linguaggi fanno eccezione, ad esempio in Eiffel la specializzazione dei metodi è covariante negli argomenti. Questo crea quello che nella comunità Eiffel è noto come "catchcall problem", che viola il principio di sostituzione di Liskov e rompe la sicurezza rispetto ai tipi del linguaggio, ma viene considerata dagli autori una caratteristica utile per tradurre in codice i requisiti di un progetto, e sono state proposte e implementate varie tecniche di analisi statica per porre rimedio al problema.

Bibliografia

• M. Abadi, A Theory of Objects, Springer New York, 2012, ISBN 978-1-4419-8598-9.