Dopo secoli da queste parti si torna a parlare di Vb.Net, e della sua interazione con Excel. Lo faccio riportando uno scambio di mail con Salvatore, iniziato da una sua richiesta di aiuto alla quale poi lui stesso ha dato una risposta:

Salvatore mi scrive:

Ciao Davis,
ho preso come riferimento il tuo codice Vb.Net per esportare in Excel che funziona benissimo. Un problema che mi assilla e’ che su determinati campi devo esportare dei numeri di telefono e me li esporta senza lo “0″ iniziale, oppure un altro dato deve essere così “359213000112892″ invece e’ così: 3,59213E+14.
Sai darmi qualche info? Anticipatamente ti ringrazio.
Saluti, Salvatore.

Io rispondo:

Ciao,
non è un problema di esportazione ma di formattazione delle celle. Excel vedendo dei numeri li interpreta come tali e quindi gli zeri davanti sono ininfluenti, e i numeri troppo grandi li rappresenta in funzione di un esponente. A te invece serve che vengano rappresentati come stringhe quindi devi andare ad agire sulla formattazione, selezionando la colonna del campo che ti da problemi e dicendogli di considerarla come testo: (tasto destro -> formato celle -> categoria: testo). Questo però, soprattutto per il fatto degli 0 iniziali, andrebbe fatto a priori; probabilmente il modo per impostare la formattazione direttamente da VB.NET ci sarà, ma sinceramente non l’ho mai fatto e purtroppo non ti so dire. Una alternativa che posso consigliarti, se nel tuo caso è applicabile, è crearti un file Excel che ti fa da Modello, vuoto, con le colonne già formattate. Ho scritto un articolo al riguardo, vedi se ti può interessare una soluzione del genere.
Spero di esserti stato di aiuto. Fammi sapere.
Ciao, Davis

Salvatore, trova la soluzione, e me la illustra:

Davis,
Intanto grazie per la cortesia.
Se ti puo’ essere utile ho trovato il sistema per formattare le colonne in base a cosa ti serve. Ad esempio:

'formatta come testo normale e quindi risolve il problema dello 0 ad inizio numero
ExcelSheet.Cells(1, 10).EntireColumn.NumberFormat = "@"
 
'formatta come valore numerico
ExcelSheet.Cells(1, 19).EntireColumn.NumberFormat = "#"
 
'formatta le celle come date nel formato indicato, che in questo caso è come mi serviva
ExcelSheet.Cells(1, 26).EntireColumn.numberformat = "ggMMaaaa"

Spero di essermi spiegato e di essere stato utile.
Ringraziandoti porgo distinti saluti,
Salvatore

Questi sono i casi in cui emergono tutta l’utilità e la potenza di un mezzo come i blog. Fantastico.

Mi scrivo qui una breve nota tecnica, che ai pochi lettori fedeli non importerà minimamente, ma che magari può servire a quanti arrivano qua dai motori di ricerca. Più che altro la scrivo qua per me, cosi se mi riserve so dove trovarla.

Se si deve aver a che fare con JSP e MySQL, dopo aver installato Tomcat, occorre scaricare e aggiungere il connector JDBC. Sul sito ufficiale e in rete ovunque si dice di infilare il file .jar dove si vuole e poi di aggiungere tale percorso alla variabile d’ambiente CLASSPATH. In realtà il posto più comodo in cui andare a metterlo, per non dover aver rogne con la modifica di variabili d’ambiente o problemi di percorsi, è nella directori base di Tomcat, quella puntata dalla variabile CATALINA_HOME, nella sottocartella lib. In questo modo se lo carica da solo e non occorre fare niente altro. Fine.

Perdere 2 ore a cercare di capire perchè l’applicazione da i numeri, le query sembrano modificare dati a caso invece di quelli corretti, studiarsi e realizzare soluzione alternative, il tutto condito da bestemmie varie ed eventuali, e poi accorgersi di aver dimenticato di chiudere un tag form. Ma porc…

Qualche tempo fa un amico mi ha chiesto se potevo risolvere l’esercizio d’esame del corso di programmazione del primo anno di ingegneria per la sua morosa. Si trattava di un programmino in C. Oggi ho ritrovato la soluzione che avevo proposto e già che ci sono faccio che parlarne, magari qualcuno con un problema simile potrebbe arrivarci e trovarlo utile.
Il testo del programma era:


Si realizzi un programma strutturato in C che gestisca il parco macchine di un autonoleggio. Il parco macchine è descritto da unfile macchine.txt avente il seguente formato: -targa- -km percorsi- -costo al km- -data- dove:
1. Il campo -targa- è una stringa di 7 caratteri che identifica in modo univoco la targa.
2. Il campo -km percorsi- è un numero intero che indica quanti Km sono stati percorsi dalla persona che ha affittato la macchina in una certa data.
3. Il campo -costo al Km- è un numero floatting point che indica il costo al Km per affittare la macchina.
4. Il campo -data- è una stringa che indica la data in cui la macchina è rientrata in sede a seguito del termine del noleggio, nel formato AAAAMMGG.
Il numero di righe contenute nel file non è noto a priori.
Un esempio di file macchine.txt è il seguente:
 
CW000GB 1200 0.10 20060105
AT736AM 150 0.15 20060106
AN150FZ 382 0.40 20060110
CW000GB 151 0.10 20060108
AN150FZ 95 0.40 20060201
 
Il programma deve fornire all'utente un menù che offra le seguenti funzioni:
1. Ricerca e stampa della targa del veicolo che, tra quelli del parco macchine dell'autonoleggio, ha percorso il numero minimo di Km.
2. Ricerca e stampa della targa del veicolo che, tra quelli del parco macchine dell'autonoleggio, è risultato essere il più remunerativo.
3. Fine del programma.


Indicazione non specificata nel testo ma da seguire comunque è quella di utilizzare come struttura dati una lista. Ok.
Il file contenente il programma è questo: noleggio.c
Esempio di file macchine.txt

Qui per continuare a leggere e vedere direttamente il codice:
(more…)

Facendo il quotidiano giro di consultazione delle statistiche del blog, ho notato qualche visita proveniente da questo thread del forum di dotnethell.it. Sono andato a curiosare e ho visto che un senior member del forum ha segnalato, linkandolo, questo mio articolo in risposta ad una richiesta di aiuto su come dividere una stringa in diverse parti separate da un determinato carattere (splittarla) e andare a leggere quelle di interesse.
Son cose che fan piacere, certo però che un misero commentino al post potevate lasciarmelo eh.

Il titolo del post presenta già in modo diretto ed esauriente quello che sarà l’argomento. Riporto infatti, adeguatamente spiegato e commentato, il codice di una mini Console Application in Visual Basic.Net (2005, framework .Net 2.0) che mi son scritto ad hoc per copiare dei dati contenuti in un file di testo su un foglio Excel dato come modello in modo del tutto automatico, lanciando solo l’applicazione da linea di comando.
Prima cosa, al solito, aggiungere il riferimento ai componenti Excel. In visual studio si va in Project, Add Reference (”Aggiungi Riferimento” nella versione in ita) e nel tab “COM” si cerca “Microsoft Excel 10.0 Object Library”, lo si seleziona e si da OK.
Veniamo al codice:

   Sub Main()
        Dim n As Integer
        Dim i As Integer
 
        'creo una nuova istanza dell'oggetto Excel Application
        Dim appExcel As New Excel.Application
        
        'dichiaro una cartella di lavoro
        Dim wbookExcel As Excel.Workbook
        
        'dichiaro un foglio di lavoro
        Dim foglioExc As Excel.Worksheet

Siccome i dati li devo inserire in un ben determinato range di celle definisco colonna iniziale e finale e riga iniziale e finale di tale range.

        Dim firstCol As Integer = 2    
        Dim lastCol As Integer = 16    
        Dim firstRow As Integer = 12
        Dim lastRow As Integer = 21
 
        'dichiaro un'oggetto StreamReader
        'che userò per leggere dal file di testo
        Dim objReader As StreamReader
 
        'rendo visibile il foglio excel (apro l'applicazione)
        appExcel.Visible = True
        appExcel.Workbooks.Add()

In questo caso il file Excel di esempio usato come modello si trova nella stessa directory di dove verrà fatto girare il programma:

        'Apro il file excel usato come modello
        wbookExcel = appExcel.Workbooks.Open(CurDir() + "\Analisi.xls")
        
        'Vado a lavorare sul foglio desiderato della cartella
        'indicandone il nome
        foglioExc = appExcel.Worksheets("Tabella2")
              
         'Associo lo streamReader al file da leggere
        objReader = New StreamReader("utilizzazione1.txt")

Inserisco i dati nelle celle desiderate con un un ciclo annidato:

'Inserisco i dati nelle posizioni desiderate
For i = firstRow To lastRow
  For n = firstCol To lastCol
                    
   'scrivo il valore letto nella cella        
   foglioExc.Cells(i, n).Value = objReader.ReadLine().Replace(".", ",")
            
  Next n
Next i

A questo proposito occorre fare una importante precisazione e cioè che qui, avendo sempre lo stesso numero di valori (150 nel mio caso) da inserire e sempre nello stesso range di celle, non ho fatto particolari controlli o gestito eccezioni. Se ad esempio nel file di testo avessi meno di 150 valori verrebbe generata un’eccezione perchè tenterei una lettura impossibile una volta raggiunto il numero di valori presenti nel file.

Altra cosa:
Il metodo Replace così invocato mi va a sostituire nella stringa che ho letto tutte i punti con le virgole. Questo ho dovuto farlo semplicemente perchè i miei dati erano dei numeri con la parte decimale separata dal punto (output di un programma in C) mentre su Excel, avendo la versione in italiano, li dovevo inserire separati dalla virgola.

        'Salvo con un altro nome cosi non altero il modello
        foglioExc.SaveAs(CurDir() + "\Utilizzazione1.xls")
        
        'chiudo
        appExcel.Quit()
    End Sub


In questo post faccio un esempio di come esportare i dati contenuti in un database Access su un foglio di calcolo Excel da una applicazione realizzata in Visual Basic.NET
Immaginiamo quindi di avere nella nostra applicazione un pulsante la cui routine di gestione dell’evento click deve andare a leggere i dati dal database e crearci un foglio di lavoro di Excel contenente gli stessi dati possibilmente formattati in un modo decente. In questo esempio (come in altri precedenti) abbiamo una tabella contenente informazioni su cd musicali (artista, titolo, ecc).
Update: mi son dimenticato una cosa importante. Ovviamente per poter utilizzare gli oggetti della libreria dei componenti Excel bisogna aggiungere il riferimento ad essa nel progetto. Per fare questo nel menù si va su Progetto -> Aggiungi Riferimento, nella finestra che si apre si seleziona il tab COM e si cerca la voce Microsoft Excel 10.0 Object Library , si clicca su Seleziona e poi Ok. Fine update.
Da qualche parte nel programma avremo quindi tutte le dichiarazioni degli oggetti necessari per operare sul database, localizzarlo, connetterlo, interrogarlo. Per maggiori informazioni al riguardo rimando a questi 2 post scritti in precedenza:

• VB.NET e Access: inserimento di un record in una tabella
• VB.NET: Recuperare dati da un database Access

Dicevamo:

Public PercorsoDB As String = "C:\Documents and Settings\prova\Documenti\Visual Studio Projects\Database\db2.mdb"
 
'Stringa di Connessione
Public ConnString As String = "Provider=Microsoft.Jet.OLEDB.4.0;" & "Data Source=" & PercorsoDB
 
Public Cn As New OleDbConnection(ConnString)
Public dr As OleDbDataReader
Public cmd As OleDbCommand
Public sql As String


Ora vediamo in dettaglio la routine di gestione dell’evento click sul pulsante per esportare i dati:

Private Sub Button1_Click(ByVal sender As System.Object, ByVal e As System.EventArgs) Handles Button1.Click
 
Cn.Open()   'apro la connessione al database
sql = "SELECT artista,titolo,genere,anno,commenti FROM album ORDER BY artista"  'query
cmd = New OleDbCommand(sql, Cn)
dr = cmd.ExecuteReader
 
Dim i As Integer = 2
Dim f As Integer
 
'Dichiaro un oggetto di tipo applicazione Excel
Dim ExcelAppl As Excel.Application
 
'Dichiaro un oggetto di tipo cartella di lavoro di Excel
Dim ExcelBook As Excel.Workbook
 
'Dichiaro un oggetto di tipo foglio di calcolo Excel(una cartella è composta da più fogli)
Dim ExcelSheet As Excel.Worksheet
 
'istanzio l'oggetto Applicazione Excel
ExcelAppl = CreateObject("Excel.Application")
 
ExcelAppl.Visible = True         'per rendere o meno visibile la finestra Excel


Impostando ExcelAppl.Visible = True si indica che si vuole aprire e rendere visibile all’utente l’istanza dell’applicazione Excel eseguita. Cioè l’utente si vede aprire la finestra di Excel allo stesso modo di come se avesse lanciato direttamente il programma Excel o aperto un documento di questo formato. Se lo si imposta a “false” non si ha l’apertura della finestra di Excel ma il lavoro viene fatto diciamo in background e alla fine della routine ci si ritrova il documento Excel creato.


'aggiungo una cartella excel all'applicazione
ExcelBook = ExcelAppl.Workbooks.Add
 
'Mi posiziono sul foglio attivo, il primo (una cartella di base ne ha 3)
ExcelSheet = ExcelBook.ActiveSheet
 
'e gli do un nome
ExcelSheet.Name = "Album (CD)"
 
'indico che i caratteri della prima riga, essendo i nome delle colonne,
'cioè i nomi dei campi del database, devono essere in grassetto
ExcelSheet.Rows.Item(1).font.bold = True
 
'Assegno un colore di sfondo alle celle che contengono i nomi dei campi del database
ExcelSheet.Range("A1:E1").Interior.Color = RGB(97, 186, 239)
 
'seleziono il range delle prime 5 (come i campi del database) celle della prima riga
'e gli imposto un bordo spesso intorno
ExcelSheet.Range("A1:E1").BorderAround(, Excel.XlBorderWeight.xlThick)
 
'imposto allo stesso range i bordi verticali tra le celle un po' più sottili
ExcelSheet.Range("A1:E1").Borders(Excel.XlBordersIndex.xlInsideVertical).Weight = Excel.XlBorderWeight.xlMedium
 
'assegno al range dei nomi delle colonne un allineamento centrale del testo
ExcelSheet.Range("A1:E1").HorizontalAlignment = Excel.XlHAlign.xlHAlignCenter
 
'allineo centralmente anche tutti i valori della colonna 4 che è il valore numerico
'che indica l'anno di pubblicazione del disco
ExcelSheet.Columns.Item(4).HorizontalAlignment = Excel.XlHAlign.xlHAlignCenter
 
'imposto la grandezza del carattere
ExcelSheet.Columns.Font.Size = 11
 
'inserisco gli effettivi valori nelle celle dei nomi delle colonne
ExcelSheet.Cells(1, 1).value = "Artista"
ExcelSheet.Cells(1, 2).value = "Titolo"
ExcelSheet.Cells(1, 3).value = "Genere"
ExcelSheet.Cells(1, 4).value = "Anno"
ExcelSheet.Cells(1, 5).value = "Commenti"
 
'ciclo che legge i valori dei record e li inserisce nel foglio
'formattando opportunamente i bordi delle celle
Do While dr.Read()
  ExcelSheet.Range(ExcelSheet.Cells(i, 1), ExcelSheet.Cells(i, dr.FieldCount)).Borders(Excel.XlBordersIndex.xlInsideVertical).Weight = Excel.XlBorderWeight.xlMedium
 
    ExcelSheet.Range(ExcelSheet.Cells(i, 1), ExcelSheet.Cells(i, dr.FieldCount)).Borders(Excel.XlBordersIndex.xlEdgeLeft).Weight = Excel.XlBorderWeight.xlThick
 
    ExcelSheet.Range(ExcelSheet.Cells(i, 1), ExcelSheet.Cells(i, dr.FieldCount)).Borders(Excel.XlBordersIndex.xlEdgeRight).Weight = Excel.XlBorderWeight.xlThick
 
    ExcelSheet.Range(ExcelSheet.Cells(i, 1), ExcelSheet.Cells(i, dr.FieldCount)).Borders(Excel.XlBordersIndex.xlEdgeBottom).Weight = Excel.XlBorderWeight.xlThin
 
'ciclo che inserisce gli effettivi valori dei campi dei record
  For f = 1 To dr.FieldCount
        ExcelSheet.Cells(i, f).value = dr(f - 1)
  Next
  i += 1
Loop
 
'imposto il bordo inferiore spesso alle celle dell'ultima riga
ExcelSheet.Range(ExcelSheet.Cells(i - 1, 1), ExcelSheet.Cells(i - 1, 5)).Borders(Excel.XlBordersIndex.xlEdgeBottom).Weight = Excel.XlBorderWeight.xlThick
 
'imposta la larghezza dell'intera colonna in base a quella della cella con larghezza maggiore
ExcelSheet.Columns.AutoFit()
 
'salvo il documento excel
ExcelAppl.ActiveWorkbook.SaveAs(Environment.CurrentDirectory & "\album.xls", , , , , , Excel.XlSaveAsAccessMode.xlExclusive)
 
Cn.Close()   'chiudo la connessione al database
 
End Sub


Siccome il codice può risultare un po’ incasinato a causa dell’eccessiva lunghezza di alcune istruzioni linko anche la versione .txt del documento dove le righe di codice risultano sicuramente più chiare.

Le 2 immagini riportate qui di seguito mostrano quello che è il risultato ottenuto:

foglio Excel con i dati esportati

anteprima di stampa

Per definire una funzione la sintassi prevede il costrutto ‘let’ seguito dal nome della funzione, dai parametri indicati nel modo (nome:tipo) e, dopo il segno di uguaglianza il body della funzione e i soliti ;; finali.
Esempio:

# let areaRett (base:int) (altezza:int) = base*altezza;;
val areaRett : int -> int -> int = fun
# areaRett 4 7;;
- : int = 28
#


la riga

val areaRett : int -> int -> int = fun

indica che la funzione areaRett deve essere chiamata con 2 argomenti, entrambi interi e che il valore che essa restituisce è ancora un valore intero. L’esempio qui sopra si dice che è una applicazione della funzione areaRett agli argomenti 4 e 7. Come si vede gli argomenti possono essere passati direttamente senza essere racchiusi ad esempio tra parentesi, anche se il mettere le parentesi non è errore. Infatti

# areaRett (4) (7);;
- : int = 28

In realtà nella definizione della funzione non è necessario indicare in modo esplicito il tipo di parametri in quanto OCaml è in grado di determinarlo in base all’operatore che gli viene applicato o da cui sono legati. Ad esempio:

# let areaRett (base) (altezza) = base * altezza;;
val areaRett : int -> int -> int = fun
# areaRett 10 3;;
- : int = 30
 
# let areaRett (base) (altezza) = base *. altezza;;
val areaRett : float -> float -> float = fun
# areaRett 2.3 2.0;;
- : float = 4.6

L’operatore *. (asterisco punto) è l’operatore per la moltiplicazione di dati di tipo float che quindi è diverso dal normale operatore di moltiplicazione di interi *
Se provo ad usarlo con degli interi ovviamente mi viene segnalato un errore

# areaRett 5 4;;
Characters 9-10:
  areaRett 5 4;;
           ^
This expression has type int but is here used with type float

Quindi a seconda dell’operatore indicato OCaml è in grado di stabilire di che tipo devono essere i parametri e quindi se accettare o meno quelli inseriti dall’utente. Questo potente meccanismo prende il nome di inferenza di tipo.

In realtà le parentesi si possono omettere e quindi la definizione finale sara’

# let areaRett base altezza = base * altezza;;
val areaRett : int -> int -> int = fun
# areaRett 3 5;;
- : int = 15

Esiste poi un altro metodo di definire una funzione del genere che consiste nel passargli una tupla (approfondirò il discorso tupla) di argomenti invece che i vari argomenti separatamente.

# let areaRett (base,altezza) = base * altezza;;
val areaRett : int * int -> int = fun
# areaRett (4,6);;
- : int = 24

La notazione int * int indica una tupla composta da 2 campi di valore intero. In questo caso la sintassi deve essere esattamente questa, con i parametri racchiusi tra parentesi tonde e separati tra loro da una virgola. Non è possibile passarli in modo diretto e neanche, ad esempio, separati da virgola ma senza parentesi.

# areaRett 4 6;;
Characters 0-8:
  areaRett 4 6;;
  ^^^^^^^^
This function is applied to too many arguments,
maybe you forgot a `;'
 
# areaRett 4,6;;
Characters 9-10:
  areaRett 4,6;;
           ^
This expression has type int but is here used with type int * int


OCaml ha un top-level interattivo che offre all’utente la possibilità di interagire con il sistema attraverso un ciclo di lettura dell’input, interpretazione, esecuzione e stampa del risultato. Quindi quello che facciamo è inserire una serie di espressioni, OCaml le valuta ‘on the fly’ e mostra il risultato ed i loro tipi. In questa interazione le linee che iniziano con # sono input e le linee che inizano con - sono gli output forniti dal sistema. Le espressioni di input possono occupare più righe e, per poter essere valutate, devono terminare con ;; (2 punti e virgola consecutivi). Ovviamente c’è anche la possibilità di compilare un intero script OCaml. Per quanto riguarda l’ambiente Windows una volta scaricato e installato Ocaml si può lanciare il top-level sia in modalità solo-testo che in modalità di interfaccia grafica utente. Per lanciarlo in modalità testuale si apre un prompt e si digita il comando ocaml (da qualunque posizione tanto la variabile di percorso viene automaticamente settata) mentre per aprire l’interfaccia grafica c’è l’iconcina (troppo figa, con un cammello con gli occhiali da sole e un filo d’erba in bocca!)

Lancio OCaml e inizio a dargli in pasto delle semplici espressioni di esempio
Objective Caml version 3.08.3
 
# 2+3;;
- : int = 5
# 3+10*2;;
- : int = 23


Assegnazioni
Per dare un nome ad una variabile o al risultato di un’espressione in modo da poterla utilizzare in seguito si usa il costrutto let
Esempi:

# let doppio x = x*2;;
val doppio : int -> int = fun
# doppio 4;;
- : int = 8
# let a = 10;;
val a : int = 10
# doppio a;;
- : int = 20


N.B. fun dovrebbe essere racchiuso tra < e > solo che l’ho tolto perchè wordpress lo vedeva come tag html e lo chiudeva automaticamente. Tanto non ha alcuna importanza è solo la parte di output che dice che il risultato è un intero determinato dal calcolo di una certa funzione. Il discorso vale anche per il pezzettino qui sotto.

La riga

val doppio : int -> int = fun

indica che la funzione doppio prende come argomento un intero e restituisce ancora un intero, ma il discorso delle funzioni, dei loro parametri e dei risultati lo affronto in un post a parte perchè ci son molti aspetti da vedere.
Questo post si ferma qui, preferisco farne molti su argomenti minimi che pochi molto lunghi e con troppa roba.

All’uni, nel corso di “Metodi formali dell’informatica I”, abbiamo iniziato a vedere un nuovo (per me) linguaggio di programmazione, OCaml. Quindi visto che parto praticamente da zero nello studio di questo linguaggio ho deciso di creare una categoria dedicata ad esso qui sul blog, dove postare man mano i nuovi argomenti affrontati, i nuovi aspetti del linguaggio visti, gli esempi e le prove che faccio, in modo da ottenere una sorta di guida, anche se probabilmente solo introduttiva, a OCaml.
Partiamo con una breve introduzione per capire di cosa stiamo parlando. OCaml è un linguaggio funzionale a differenza di altri linguaggi, come il C, che invece sono linguaggi imperativi.
Le principali caratteristiche di un linguaggio funzionale sono:

• Strutture dati immutabili: cioè persistenti, una volta che sono state definite non possono più essere modificate. Se definisco una lista e poi voglio eliminare un elemento, la lista che ottengo come risultato è una nuova lista a tutti gli effetti e non quella iniziale modificata.
• La struttura di controllo principale è la ricorsione.
• Vengono utilizzate funzioni di ordine superiore: le funzioni di ordine superiore (chiamate anche “functionals”) sono quelle funzioni che prendono come parametri (argomenti) delle altre funzioni e in alcuni casi ritornano a loro volta una funzione.

Nei linguaggi imperativi, prendiamo sempre a riferimento il C, abbiamo invece:

• Strutture dati mutabili.
• Iterazione (quindi loop, cicli) come struttura di controllo principale: da notare il “principale”, infatti anche nel C la ricorsione viene molto utilizzata per diversi tipi di problemi ma i cicli rapprensentano una parte basilare e compaiono praticamente in ogni programma.
• Uso di funzioni del primo ordine: cioè di funzioni che prendono in input e restituiscono in output dei dati semplici (int, char) o delle strutture (array).

Ok, è stato presentato il discorso ad un livello più generale possibile. Dal prossimo post, di categoria ovviamente, si parlerà nello specifico di OCaml.