Schemi di Scheme

Avevo gia' introdotto Scheme e il SICP.

Ora che abbiamo superato le "banalita'", si iniziano a discutere concetti interessanti. Ad esempio, nel 2.4 praticamente viene spiegato come si esegue una conversione di tipo.

Concetti gia' noti in C, ma non da questa prospettiva! Ad esempio, la conversione di tipi viene e la suddivisione dei programmi vengono fatte in modo molto piu' grezzo (Scheme e' un linguaggio molto minimale, per questo va bene nello studio dei linguaggi).

Praticamente si arriva a fare a mano il dispatching delle funzioni di conversione :) Cosa abbastanza interessante.

Sebbene tante cose che scopro in Scheme siano presenti in altre forme anche in C e C++ (ad esempio, in C non ci sono le higher-order functions, ma i puntatori a funzione permettono di usarle come tali), il metodo stesso con cui si programma in Scheme mi attira molto.
La programmazione funzionale, insomma.

Ad esempio, l'uso dei let nel codice introduce un nuovo modo di vedere gli scope, cosa che in C non si usa. Quando mai vedete codice tipo il seguente?

int foo(int bar, float baz)  {
  { // EH?
    int tmp = bar * 2;
    if (tmp < 42)
      baz -= tmp / 3.0;
    else
      baz += tmp / 3.0;
  } // E queste??
  baz *= 3.14159265;
  return ceiling(baz);
}

(E' codice inutile eh :D Non cercateci dietro matematica sensata.) Questo sarebbe un uso corretto degli scope: tmp vive tra quella coppia di parentesi graffe. In scheme, il lavoro delle parentesi graffe (e della dichiarazione di tmp) la fa let. Ed e' naturale, come modo di fare. Ma implica un sacco di cose graziose: il codice e' piu' strutturato, contiene piu' informazioni (viene impressa una semantica solitamente trascurata), quindi un compilatore potrebbe, ad esempio, ottimizzare in modo migliore il codice.

Anzi: ammettendo un compilatore "scrauso" (che non analizza a priori lo scope delle variabili), questa sarebbe gia' una ottimizzazione: riducendo lo scope di tmp, si evita che quell'oggetto persista in memoria. La chiusura delle graffe corrisponde ad un "ora quello che ho creato qui dentro non mi serve piu', ottimizza tu come preferisci".

Questo e' bene, perche' si sta dando al compilatore una informazione preziosa.
Ma in scheme, che le variabili non sono tipizzate e dichiarate in questo modo, questo modo di fare viene quasi "imposto", quindi il codice e' strutturato per natura.

Lo dico cosi', di fretta, ma ai miei occhi e' la cosa piu' importante: teniamo presente che Scheme e' un linguaggio per la manipolazione simbolica :) A voi le conclusioni.

Stay --sync