Nim e interoperabilità

In questa lezione esploreremo come il linguaggio di programmazione Nim permette di interfacciarsi con altre tecnologie e linguaggi di programmazione, rendendolo uno strumento estremamente versatile. Approfondiremo tre aspetti fondamentali dell'interoperabilità: interfacciarsi con C/C++, generazione di codice JavaScript e Integrazione con altre piattaforme.

Interfacciarsi con C/C++

Uno degli aspetti più potenti di questo strumento è la sua stretta integrazione con il linguaggio C e, in misura leggermente minore, con C++. Questa caratteristica ci consente di utilizzare librerie e funzioni scritte in C o C++ direttamente nel nostro codice Nim senza dover ricorrere a complesse operazioni di wrapping o binding. L'approccio che Nim adotta per questa integrazione è progettato per essere il più fluido e naturale possibile.

Importazione di codice C

Creiamo una funzione C che utilizza printf per stampare un messaggio. Salviamo questo codice in un file chiamato myprint.c.

// myprint.c
#include 
void myPrint(const char* message) {
    printf("%s\n", message);
}

Questa funzione myPrint prende una stringa come argomento e la stampa a schermo.

Ora vediamo come importare e utilizzare la funzione C in Nim.

1. Creazione del file C: salva il codice C in un file chiamato myprint.c.
2. Compilazione del codice C: compila il codice C in un file oggetto .o

gcc -c myprint.c -o myprint.o

Questo comando genera il file oggetto myprint.o. Ora scriviamo un programma Nim che utilizza la funzione myPrint.

# myprint_example.nim
# Dichiarazione della funzione C nel codice Nim
proc myPrint(message: cstring) {.importc.}
# Esempio di utilizzo della funzione importata
let msg = "Ciao dal codice Nim tramite C!"
myPrint(msg)

Compiliamo ed eseguiamo il programma, assicurandoci di collegare correttamente il file oggetto myprint.o:

nim c -d:release --passL:myprint.o myprint_example.nim
./myprint_example

Gestione di tipi complessi

Un altro punto di forza dell'integrazione con C è la gestione dei tipi complessi. Nim può lavorare con strutture, unioni e puntatori definiti in C. Ad esempio, se abbiamo una struttura C come la seguente:

struct Point {
    int x;
    int y;
};

Possiamo interfacciarci con questa struttura in Nim come segue:

type
  Point* = object
    x*: cint
    y*: cint

Questa dichiarazione Nim riflette direttamente la struttura C, permettendoci di passare dati tra C e Nim in modo semplice e sicuro.

Interazione di Nim con C++

L'interazione con C++ è leggermente più complessa a causa delle differenze semantiche tra Nim e C++. Tuttavia Nim offre strumenti per includere classi e funzioni C++ nel codice Nim. Ad esempio:

{.emit: """#include <iostream>""".}
proc cpp_hello*() {.importcpp: "std::cout << 'Hello from C++!\n';".}
cpp_hello()

Questo esempio mostra come possiamo utilizzare importcpp per eseguire codice C++ all'interno di Nim.

Generazione di codice JavaScript

Un'altra caratteristica chiave del linguaggio è la sua capacità di compilare codice in JavaScript, aprendo la strada allo sviluppo di applicazioni web e mobile. Esso trasforma automaticamente il codice scritto in Nim in JavaScript, preservando la sintassi e le strutture di alto livello, ma traducendole in modo efficiente nel linguaggio del browser.

Per creare un'applicazione web in Nim, tutto ciò che dobbiamo fare è scrivere il nostro codice in Nim e poi compilare con il backend JavaScript. Ad esempio, possiamo creare una semplice funzione che stampa un messaggio sulla console del browser:

proc sayHello() =
  echo "Ciao dal codice Nim, compilato in JavaScript!"
when isMainModule:
  sayHello()

Compilando questo codice con nim js -d:nodejs hello.nim, otterremo un file .js eseguibile su Node.js o direttamente in un browser. Questo processo di compilazione trasforma la nostra funzione Nim in una funzione JavaScript, che mantiene la stessa logica ma con una sintassi che il browser può eseguire.

Interazione con le API del Browser

Uno degli aspetti più utili della generazione di JavaScript è la possibilità di interagire con le API native del browser. Ad esempio, possiamo manipolare il DOM o utilizzare l'API Fetch per effettuare richieste HTTP, tutto direttamente da un codice come quello proposto di seguito:

proc fetchData(url: cstring) {.async.} =
  let response = await fetch(url)
  let data = await response.text()
  console.log(data)
when isMainModule:
  fetchData("https://api.example.com/data")

In questo esempio, utilizziamo fetch, un'API JavaScript, per la richiesta HTTP. Nim ci permette di scrivere codice asincrono in modo naturale, il quale verrà poi tradotto in Promises e callback in JavaScript.

Supporto per le librerie JavaScript

Nim supporta anche l'uso di librerie JavaScript esistenti. Possiamo importare moduli JavaScript come se fossero moduli Nim, utilizzando importjs. Ad esempio, per usare Lodash, una popolare libreria JavaScript per la manipolazione degli array:

{.emit: """import _ from 'lodash';""".}
proc mapArray*(arr: seq[int]): seq[int] {.importjs: "_.map(#, x => x * 2)".}
let nums = @[1, 2, 3, 4]
let doubled = mapArray(nums)
console.log(doubled)

In questo codice, utilizziamo direttamente una funzione di Lodash per raddoppiare i valori di un array. Nim si occupa di tradurre questa chiamata in codice JavaScript compatibile.

Integrazione di Nim con altre piattaforme

Il linguaggio non si limita solo ad interoperare con C/C++ e JavaScript; la sua flessibilità lo rende ideale per l'integrazione con molte altre piattaforme, dai sistemi operativi ai motori di gioco, passando per le applicazioni mobile.

Integrazione di Nim con Python

Uno degli usi più comuni è l'integrazione con Python. Grazie a nimpy, un modulo progettato per interfacciarsi con Python, possiamo chiamare funzioni Python dal codice Nim e viceversa.

Per prima cosa dobbiamo installare nimpy, quindi, assicurandoci di aver installato git nel nostro sistema operativo, scriviamo:

nimble install nimpy

Adesso siamo in grado di scrivere un esempio:

import nimpy
let py = pyBuiltinsModule()
discard py.print("Hello world from Python..")

Una volta eseguito questo programma verrà generato un file .exe che, una volta lanciato da terminale, restituirà la stringa "Hello world from Python..".

Volendo scrivere qualcosa di un pò più complesso, possiamo provare:

import nimpy
let np = pyImport("numpy")
let arr = np.array([1, 2, 3])
echo arr.sum()

In questo esempio, importiamo la libreria numpy di Python e la utilizziamo per creare un array e calcolare la somma dei suoi elementi, tutto direttamente da Nim. Questo tipo di interoperabilità è ideale per sfruttare la vasta gamma di librerie disponibili in Python senza sacrificare le prestazioni di Nim.

Conclusioni

L'interoperabilità di Nim lo rende una scelta eccellente per sviluppatori che desiderano combinare la semplicità e la sicurezza di un linguaggio moderno con la potenza e la versatilità di tecnologie consolidate come C/C++, JavaScript, e altre piattaforme. Che stiamo sviluppando applicazioni web, mobile, o Desktop, esso offre gli strumenti necessari per integrarsi senza soluzione di continuità con l'ecosistema esistente, migliorando la produttività senza compromettere le prestazioni.

In questa guida abbiamo visto una panoramica delle caratteristiche principali del linguaggio e dei suoi punti di forza, sottolineando perché potrebbe essere una scelta eccellente per diversi tipi di progetti. E' chiaro che il linguaggio ha molto da offrire e merita attenzione nel panorama della programmazione moderna.