====== Reificazione ======
//Reificazione, si è una parola Italiana ...//

PREV [[evoluzione_non_rivoluzione]]

===== Defnizioni di reifcazione =====
Processo mentale mediante il quale a concetti astratti viene assegnata consistenza di cose concrete

Nella flosofa di Marx, processo secondo cui nell'economia capitalistica l'uomo e il suo lavoro sono ridotti al valore della merce che producono

La reifcazione è una fallacia o un'ambiguità quando un'astrazione (una credenza astratta o un costrutto ipotetico) viene trattata come se fosse un concreto evento reale o un'entità fsica

Nell'ambito dell'Ingegneria della conoscenza, e in particolare della defnizione di ontologie, la reifcazione è una rappresentazione indiretta che prevede l'utilizzo di determinate espressioni del linguaggio per descrivere entità del mondo reale intuitivamente associate a espressioni di tipo diverso. L'esempio tipico di reifcazione è costituito dall'utilizzo di individui per rappresentare classi.

Nel contesto della programmazione orientata agli oggetti si defnisce reifcazione il procedimento di creazione di un modello di dati basato su un concetto astratto predefnito. Mediante la reifcazione, un computer può compiere elaborazioni riguardanti un'entità astratta come se si trattasse di un insieme qualsiasi di dati di altro tipo



===== Unchecked cast =====

Non sempre il compilatore è in grado di capire se un cast verso un tipo non reifcabile avrà successo
I sistemi di tipi (dei linguaggi di programmazione orientati agli oggetti) non sono perfetti e non possono individuare situazioni di successo come può fare un (buon) programmatore
Per questo motivo un cast verso un tipo non reifcabile non genera un errore ma un warning



===== In java =====
In java un tipo è reifcabile se il tipo è completamente identifcabile a runtime, ovvero se la type erasure non rimuove informazioni utili


===== Tipi reifcabili =====

  * Primitivi es: int
  * Classi o interfacce non parametriche es: String, Comparable
  * Tipi parametrici in cui tutti gli argomenti di tipo sono wildcard non limitati es: List<?> o Map<?,?>
  * Raw type es: List, Map Array di elementi di tipo reifcabile es: int[] , List<?>[]


===== Tipi non riefcabili =====

  * Variabili di tipo es: T in Xxxx<T>
  * Tipi parametrici con parametri attuali es: List<String>, Comparable<Integer>
  * Tipi parametrici con un limite es: List<? extends String> , Comparable <? super Number>



===== Note =====

In java il tipo di un array viene reifcato con il tipo dei suoi componenti
Un tipo parametrico non viene reifcato con il suo parametro di tipo
List<?> è equivalente a List<? extends Object> (nel senso di passaggio di parametri) ma il primo è reifcabile il secondo no




===== Instance test e cast =====

I test instanceof ed i cast dipendono dall'esame a runtime dei tipi degli oggetti coinvolti e quindi dalla reifcazione
Test di istanza verso un tipo non reifcabile → errore (di compilazione)
Cast ad un tipo non reifcabile → genera (di norma)	un warning



<code java>
public class Myinteger {
  private final int value; public boolean equals(Object o) {

Myinteger è reificabile → il cast non genere warning
if (o instanceof Myinteger){  // ynteger è reificabile → compila

return this.value ==
((Myinteger)o).value; } else return false; // Myinteger è reificabile → il cast non genere warning
} ...
}
</code java>

===== Equals su liste =====
<code>
public abstract class MiaLista<E> extends AbstractCollection<E> implements List<E>{
public boolean equals(Object o){ if ( o instanceof List<E>){
Iterator<E> it1 = iterator(); Iterator<E> it2 = ((List<E>)o ).iterator(); while (it1.hasNext() && it2.hasNext()){
E e1 = it1.next(); E e2 = it2.next(); if (! ( e1 == null ? e2== null: e1.equals(e2) ) ){
return false; }
}
} }
return !it1.hasNext() && !it2.hasNext(); } else return false;
</code>

===== Equals su liste: analisi =====
<code java>
public abstract class MiaLista<E> extends AbstractCollection<E> implements List<E>{
public boolean equals(Object o){ if ( o instanceof List<E>){ Iterator<E> it1 = iterator();  // Errore di compilazione! List<E> non è reificabile
Iterator<E> it2 =
((List<E>)o ).iterator(); while (it1.hasNext() // Unchecked cast warning!
&& it2.hasNext()){ ...
</code>


===== Equals su liste: versione fxata =====
<code java>
public abstract class MiaListaOK<E> extends AbstractCollection<E> implements List<E>{
Iterator<E> it1 = iterator(); Iterator<?> it2 = ((List<?>)o ).iterator(); while (it1.hasNext() && it2.hasNext()){
return false; }
}
}
return !it1.hasNext() && !it2.hasNext(); } else return false;
</code>
==== Analisi ====
<code java>
public abstract class MiaListaOK<E> extends AbstractCollection<E> implements List<E>{ public boolean equals(Object o){
if ( o instanceof List<?>){ Iterator<E> it1 = iterator(); // OK List<?> è reificabile
 Iterator<?> it2 = (
(List<?>)o ).iterator(); // List<?> è reificbaile e non vengono generati warning
while (....
Object e2 = it2.next(); // Da una List<?> posso prelevare Object senza problemi
</code>



===== Cast non reifcabili =====

Test di istanza verso tipi non reifcabili generano sempre errore In alcune circostanze un cast ad un tipo non reifcabile può
non generare warning


==== Nessun warning ====
<code java>
public static <T> List<T> asList(Collection<T> c )
throws IllegalArgumentException { 
 if ( c instanceof List<?>){ // List<?> è reificabile → compila
return (List<T>)c; } else throw new // Il cast non genera waring in quanto la sorgente del cast ha tipo Collection<T> 
                                    // e ogni oggetto di questo tipo che implementa List deve avere come tipo List<T>

IllegalArgumentException("Il parametro passato non e' un sottotipo di List<T>");
</code>



<code java>
public static List<String> converti(List<?> oggetti){ for (Object obj: oggetti){ //Il cast “a logica” non fallirà mai
if (!( obj instanceof String)){ throw new IllegalArgumentException( ... // OK String è reificabile
}}
return
(List<String>)(List<?>)oggetti; } // Unchecked Cast ← il compilatore non è in grado di capire se il cast avrà successo o meno

</code>

**Nota: è illegare “castare” una lista di oggetti ad una lista di stringhe, quindi serve il doppio cast **


===== Array e reifcazione =====
Gli array reifcano i loro componenti ovvero conservano a runtime i tipi dei loro componenti


==== Un vecchio esempio ====
<code java>
Integer[] interi = new Integer[] {1,2,3}; // OK, gli array sono covarianti
Number[] numeri = interi;
numeri[2] = 3.14; // ArrayStoreException Double non è compatibile con il tipo reificato dell'array
</code>



==== Creazione di array ====
<code java>
public static <T> T[] toArray(Collection<T> c){

T[] ret= new T[c.size()];  // NO! errore di compilazione
int i = 0 ; for (T x :c){ret[i++] = x;} return ret;
}
</code>
Le variabili di tipo non sono reificabili → viene generato un generic array creation error
<code>
Cannot create a generic array of T 
</code>
==== Difetti ... ====

Non poter creare array di generics è una limitazione di java Array generici sono problematici a causa della erasure (tuttavia) erasure facilita l'evoluzione 

In generale ... dire “no!” ad array ed utilizzare il Collection Framework

==== Refection ... ====

Tramite refection è possibile ovviare al problema della creazione di array generici

==== Dont' try this at home ====
<code java>
public static <T> T[]toArray(Collection<T> coll){
T[] ret = (T[]) new Object[coll.size()];  // Unchecked Cast!
int i = 0 ;
 for (T x :coll){ret[i++] = x;} 
return ret;
} --- 
List<String> stringhe = ... String[] a = toArray(stringhe); // Class Cast Exception
</code>
<code>
Exception in thread "main" java.lang.ClassCastException: [Ljava.lang.Object; cannot be cast to [Ljava.lang.String;
at generics.cap6.Ex1.main(Ex1.java:23)
</code>


==== Messaggio oscuro ====

<code java>
Exception in thread "main" java.lang.ClassCastException: 
[Ljava.lang.Object; cannot be cast to [Ljava.lang.String;
at generics.cap6.Ex1.main(Ex1.java:23)
</code>

  * L signifca array di reference type
  * [LObject signifca array di Object, Object è il component type dell'array
  * L'errore non viene segnalato nel punto in cui viene generato (!) ma in un altro punto (!!!) ovvero nel main
==== Versione generata dall'erasure: analisi ====
<code java>
public static Object[] toArray1( Collection coll){
Object[] ret = (Object[]) new Object[coll.size()]; // Unchecked Cast sparito! --> Erasure: converte il cast a T[] in un Cast a Object[]
int i = 0 ; 
for (Object x :coll){
ret[i++] = x;} 
return ret; }
 --- List<String> stringhe =
Arrays.asList("ciao","mondo"); 
String[] a = (String[])toArray(stringhe); //ClassCastError --> Erasure: inserisce il cast a String[]
</code>

**Attenzione! Nonostante l'array contenga solamente stringhe, il suo tipo reifcato è un array di Object! **
==== Cast iron guarantee (ancora) ====

I cast inseriti dall'erasure non falliscono mai a parte quando viene generato un unchecked cast warning
Quando viene generato un unchecked cast warning allora i cast inseriti dalla erasure
  * Possono fallire
  * Possono essere segnalati in parti del codice diferenti da quella che ha generato l'errore


===== Adoro i soldi che generano i soldi =====

A volte un modo per fare soldi è tramite altri soldi. Lo stesso si può applicare agli array: generare array tramite un altro array

<code java>
public static <T>
 T[] toArray( Collection<T> coll, T[] arr){
 T[] ret = null; ret = (T[])java.lang.reflect.Array.newInstance
(arr.getClass().getComponentType(), // unchecked cast
coll.size());
int i = 0; for (T elem: coll) ret[i++] = elem; return ret; }
}
</code>

==== Esecuzione del codice ====

<code java>
List<String> a= Arrays.asList("ciao","a");
String[] st = toArray(a, new String[0]);
for (String s: st) System.out.println(s);
</code>
  * Ok! Funziona!
  * Il metodo getCoponentType() restituisce un “Class Object” che rappresente il tipo dei componenti dell'Array T
  * Class<?> ctype = arr.getClass().getComponentType(); Nel nostro caso è String

==== La versione "di classe" ====
<code java>
public static <T> T[] toArray( 
Collection<T> coll, Class<T> classse){
 T[] ret = null; 
 ret = (T[])java.lang.reflect.Array.newInstance (
   Classse, coll.size() ); 
 int i = 0; for (T elem: coll) ret[i++] = elem; 
return ret; }
</code>

<code java>
List<String> a= Arrays.asList("ciao","a");
String[] st2 = toArray(a, String.class);
</code>