• Dopo svariati anni ho cambiato completamente la pagina nella root di questo dominio pensando a qualcosa di molto semplice ma decisamente più utile di quella precedente.
• Twitter rules (lo ribadisco) e no, niente Facebook (ci tengo a ribadire anche questo).
• Alla fine in Giappone ci sono stato! Circa 10 mesi fa a dire il vero. Che dire, ci vorrebbe un blog intero solo per raccontare l’esperienza. Ovviamente nei piani è previsto un ritorno in pompa magna nel paese del Sol Levante, ma in un periodo non ancora definito. Posterei anche qualche fotografia, se solo avessi finito di sistemarle (sono fermo a 330 su circa 1200 foto).
• Evviva gli EeePC. Windows 7 + Kubuntu sul disco e ArchLinux (con fluxbox) su chiave USB e posso fare praticamente tutto ovunque io sia. Tra l’altro è solo qualche mese che utilizzo ArchLinux ma devo ammettere che mi sta piacendo molto come distribuzione.
• Vorrei scrivere un blog "tecnico" in inglese, ma come potrei anche solamente pensarci quando non riesco ad aggiornare nemmeno quello nella mia lingua madre?
• Tra l’altro girano leggende metropolitane tra qualche persona che conosco secondo cui un post che compare su questo blog è presagio di impressionanti catastrofi, o quanto meno di tempo metereologico palesemente avverso per il fine settimana. Nel dubbio oggi è caduta grandine, per il weekend staremo a vedere.
• Ah, buona Pasqua.
• 42

OK, lo ammetto, in realtà era tutta una scusa per postare qualcosa dopo un anno esatto Mi piacerebbe ripartire, ma dovrei trovare prima il tempo e saper scegliere tra la miriade di argomenti che potrei trattare. Non sono sicuro di riuscirci, ma vedremo come andrà

• Ho iniziato a usare GitHub, di conseguenza Git come DVCS, per condividere il codice su cui lavoro. C’è un po’ di tutto: esperimenti come couchdb-lua-viewserver oppure hpricot-pure ma anche lavori un po’ più utili e seri come redis-lua oppure ironruby-hpricot e ironruby-json.
• Proprio ironruby-hpricot e ironruby-json rappresentano i miei primi due progetti concreti per IronRuby e sono i rispettivi i port delle librerie hpricot e json (entrambe basate su Ragel) che sono disponibili per l’MRI. Ora come ora mi sto divertendo focalizzandomi principalmente sulla compatibilità di IronRuby con l’MRI, come del resto testimoniato dalla natura della decina di bug report che ho aperto, ma prima o poi inizierò anche con qualche progetto che si integri con il framework .NET (e ho già qualche idea in merito, manca solo il tempo).
• Con Twitter ormai ci ho preso gusto, soprattutto negli ultimi 6 mesi. Ho potuto seguire botte-e-risposta interessanti, sono potuto entrare in contatto con gente altrettanto interessante e tecnicamente molto preparata, inoltre la velocità con cui è possibile catturare notizie è stupefacente. Certamente la percezione di "interessante" e di "utile" può variare da persona a persona ed è proprio per questo che, a chi fosse ancora scettico, non posso far altro che dire che solo con la prova sul campo è possibile carpirne le potenzialità. Per la cronaca io stesso ero uno dei poco convinti, se non addirittura uno dei suoi quasi-detrattori. Ah, per inciso non mi iscriverò mai a Facebook. Si lo so, mai dire mai, ma c’è sempre l’eccezione che conferma la regola.
• Il mese scorso ho riesumato anche il mio tublelog, con tanto di nuovo look visto che quello vecchio faceva abbastanza schifo (il nuovo tema è uno di quelli disponibili sulla galleria di temi di Tumblr ma con modifiche e adattamenti sparsi).
• Giappone! Finalmente si sta per concretizzare un viaggio che per motivi sempre differenti sono stato costretto a rinviare più volte negli ultimi 6 anni. In realtà è già tutto pronto, manca solo la partenza OK non c’entra nulla con le mie attività online, ma mi andava di dirlo lo stesso.

Per ora chiudo qui, credo di avervi tediato abbastanza. Ora vedremo se riuscirò a tener fede al fatto che questo post non vuole essere uno pesce d’Aprile, ovvero spero di riuscire a non scrivere il prossimo messaggio tra altri 5 mesi ma di dargli un seguito con qualcosa di più interessante e tecnico entro breve.

Il problema principale della scelta di :: come separatore per i namespace, secondo i core developer di PHP, risiede nel fatto che in alcuni casi può crearsi un’ambiguità non risolvibile dall’interprete poiché lo stesso :: viene usato anche per accedere ai metodi di classe statici. Ecco un esempio pratico:

 1 // --------------------------------------
 2 // primo caso: Classe::methodoStatico()
 3 
 4 class Foo {
 5     public static function bar() {
 6         echo "Foo::bar()";
 7     }
 8 }
 9 
10 Foo::bar();
11 
12 // --------------------------------------
13 // secondo caso: Namespace::funzione()
14 
15 namespace Foo;
16 
17 function bar() {
18     echo "Foo::bar()";
19 }
20 
21 Foo::bar();

L’ambiguità delle righe 10 e 21 risulta evidente, tanto che anche l’interprete in questo caso non saprebbe come comportarsi. Per questo motivo gli sviluppatori di PHP hanno pensato di aggirare il problema cambiando appunto in \ il separatore per i namespace.

Se doveste chiedermi cosa ne penso vi direi che, così di primo acchito e pur non avendo da offrire soluzioni in merito alla questione, per conto mio l’idea non è stata delle migliori. Senza alcun dubbio c’erano dei problemi, ma se da un lato è vero che così vengono risolte possibili ambiguità, con la scelta di \ vedo l’introduzione di bug subdoli dovuti alla mancata attenzione nell’uso della quotazione singola o, in caso contrario, un errato escaping.

$singleQuote = new ReflectionClass('foo\bar\className');
$doubleQuoteWithEscape = new ReflectionClass("foo\\bar\\$classNameInVar");

Ad ogni modo vi fornisco alcuni link la cui lettura può tornarvi utili per farvi un’opinione sulla decisione presa:

• Use \ as namespace separator e Description of what it means to use \ as namespace separator.
• Request for Comments: Namespace Separators
• Annuncio del cambiamento sulla mailing list php.internals

Microsoft announced plans to support additional tools for developing Silverlight applications by providing funding to Soyatec, a France-based IT solutions provider and Eclipse Foundation member, to lead a project to integrate advanced Silverlight development capabilities into the Eclipse IDE. Soyatec plans to release the project under the Eclipse Public License Version 1.0 on SourceForge and submit it to the Eclipse Foundation as an open Eclipse project.

Potete trovare maggiori dettagli in questa pagina fresca di pubblicazione, inoltre è stato reso noto il sito Eclipse Tools for Microsoft Silverlight su cui è già online e disponibile per il download una prima alpha del plugin per Eclipse con dettagli e istruzioni su alcune modalità di configurazione. Nella stessa pagina si può notare anche una curiosa nota: Windows XP SP2 (or above) or Windows Vista SP1 – Other OS are planned for future versions. In effetti mi chiedo quanti sviluppatori .NET su Windows usino Eclipse, considerazione che riporta un po’ tutti con i piedi per terra, però quel futuro supporto per altri sistemi operativi… mah, chissà…

Ad ogni modo l’altra notizia (di cui non ci sono ancora testimonianze ufficiali scritte mentre sto scrivendo) è che a quanto pare Microsoft e Nokia lavoreranno per portare Silverlight su piattaforma Symbian.

Per ora sembrerebbe non esserci altro. E dire che il PDC 2008 è tra meno di quindici giorni…

We will distribute the jQuery JavaScript library as-is, and will not be forking or changing the source from the main jQuery branch.  The files will continue to use and ship under the existing jQuery MIT license.

Il secondo invece arriva dal post di Scott Hanselman (e che in effetti riassume uno dei principali motivi per cui questo annuncio mi ha stupito):

Folks have said Microsoft would never include Open Source in the platform, I’m hoping this move is representative of a bright future.

Ecco i rispettivi annunci ufficiali da parte di Scott Guthrie e John Resig (il quale estende la notizia riportando anche la collaborazione ufficiale di jQuery con Nokia).

# main.rb

require 'rubygems'
require 'sinatra'

get '/' do
    'Cool, Sinatra is performing on the main stage!'
end

Usando il comando ruby main.rb si ottiene un’istanza di Mongrel con la nostra applicazione pronta a ricevere le chiamate dal browser, mentre nella finestra del terminale si viene avvisati che Sinatra has taken the stage on port 4567! Non resta da far altro che verificare l’effettivo funzionamento con un semplice wget -qO- http://localhost:4567/ (oppure curl http://localhost:4567/ se preferite):

Cool, Sinatra is performing on the main stage!

Sinatra può essere definito un micro-framework traverstito da DSL dotato di una grammatica ridotta, semplice e immediata. Sinatra non obbliga lo sviluppatore a strutturare la propria applicazione seguendo l’architettura MVC (ma è comunque possibile replicarla), non è legato a un particolare motore di template (ma supporta molto bene ERB e l’ottimo HAML), non offre la miriade di helpers inclusi nel prezzo come altri framework e inoltre è assolutamente ORM-agnostico: tutto ciò può avere i suoi pro e contro, ma queste caratteristiche lo rendono indubbiamente un ottimo framework per lo sviluppo di prototipi o di applicazioni semplici ma relativamente veloci. Sinatra, per come è strutturato, promuove inoltre lo sviluppo di interfacce REST per le proprie applicazioni web, rendendolo quindi uno strumento agevole per prototipizzare API.

get '/' do
    # mostra risorsa
end

post '/' do
    # crea risorsa
end

put '/' do
    # aggiorna risorsa
end

delete '/' do
    # cancella risorsa
end

Viene naturale a questo punto chiedersi come vengano gestite le rotte, ma anche in questo caso è tutto molto semplice e intuitivo:

get '/hello' do
    redirect '/hello/anonymous'
end

get '/hello/anonymous' do
    'Hello Mr. Anonymous, I would be glad to know your name!'
end

get '/hello/:name' do
    user = params[:name]
    "Hello, #{user}!"
end

# wget -qO- http://localhost:4567/hello
# Hello Mr. Anonymous, I would be glad to know your name!

# wget -qO- http://localhost:4567/hello/anonymous
# Hello Mr. Anonymous, I would be glad to know your name!

# wget -qO- http://localhost:4567/hello/NRK
# Hello, NRK!

Occorre solamente far notare che Sinatra effettua il lookup delle rotte nell’ordine di definizione, per questo motivo la seconda rotta /hello/anonymous non viene catturata dalla terza che invece specifica un più generico /hello/:name. Concentrandosi appunto su quest’ultima, possiamo notare come più in generale le variabili all’interno di una rotta possano essere definite semplicemente sfruttando la stessa sintassi utilizzata per definire un simbolo in Ruby e come esse vengano automaticamente rese disponibili nell’hash params.

Se avessimo bisogno di un approccio più in stile MVC? Partendo dal presupposto che con Sinatra non serve creare una classe controller ma basta definire le singole azioni, a questo punto mancano solo le viste. Occorre quindi creare una directory views nel path della nostra applicazione, preparare il proprio template salvando il file relativo nella suddetta directory (per esempio greet.haml oppure greet.erb a seconda di quale motore di template vogliate usare) e scrivere una semplice riga di codice per la rotta:

get '/hello/:name' do
    haml :greet
end

Per convenzione Sinatra effettua l’autocompletamento del nome del file della vista aggiungendo .haml o .erb, per cui basta specificarne il nome. Se avessi voluto utilizzare erb avrei scritto erb :greet ma dal momento che haml tutto sommato mi piace (gem install haml), ecco qui il codice d’esempio assolutamente minimale:

!!!
%html
  %head
    %title Greetings!
  %body
    %span
      Hello,
      %strong= params[:name]

A questo punto la chiamata a http://localhost:4567/hello/NRK produrrà il seguente output:

<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN"
    "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
<html>
  <head>
    <title>Greetings!</title>
  </head>
  <body>
    <span>
      Hello,
      <strong>NRK</strong>
    </span>
  </body>
</html>

Tutto molto semplice, no?

Sinatra è in una fase di sviluppo abbastanza attiva ma è un framework già particolarmente interessante per tutte quelle necessità in cui Ruby on Rails oppure framework similari risulterebbero soluzioni spropositate. Essendo basato su Rack è possibile servire le applicazioni usando server differenti da Mongrel, come per esempio Thin o Phusion Passenger via Apache. Personalmente lo sto provando nei ritagli di tempo per creare una sorta di gateway da un servizio JSON-RPC che avevo realizzato qualche tempo fa a un servizio REST-oriented con tanto di interfaccia web per la gestione delle azioni e la visualizzazione dei dati, per ora sono molto soddisfatto della sua semplicità.

Digressioni & deliri messi da parte, ci terrei a confessarvi di avere una discreta quantità di argomenti utili e interessanti (spero) su cui scrivere, mi auguro di avere il tempo materiale per riuscire nell’impresa, prima però preferirei seguire un percorso riabilitativo al posting abbastanza dolce per cui… ecco il temibile tag <ul/>, una bella unordered list per voi:

• Chrome. Google è un fenomeno del marketing, me lo fa pensare il fatto che tutti stiano andando pazzi per un browser che fondamentalmente… crasha. Ehi, però crashano i singoli tab, mica tutto il browser: accidenti scusate, allora è tutto ok posso unirmi al delirio generalizzato! Ironie e crash a parte, il browser è veloce e in effetti v8 è una scheggia, magari non sempre sovraumana in tutte le circostanze come vorrebbero far credere con i benchmark studiati ad hoc ma si tratta comunque dell’engine ECMAScript/Javascript più performante attualmente in circolazione, lo sta dimostrando con dei fatti. Il browser in sè potrebbe non essere malvagio, ma magari ci rivedremo più avanti quando Google l’avrà sistemato ancora un po’, avrà fatto uscire qualcosa di compilato anche per le altre piattaforme e magari, già che sono in ballo, avrà smesso di fare presunti pasticci con l’EULA. Per ora sulla mia macchina virtuale linux di sviluppo sono rimasti solo i sorgenti di v8 e il risultato della loro compilazione, mi interessano molto di più di tutto il resto.
• A proposito di macchine virtuali, ho acquistato una VPS linux con SliceHost scegliendo il loro piano di base da 20$/mese. In seguito ho registrato un nuovo nome di dominio con Aruba (mi tornava comodo solo per la registrazione, infatti ho provveduto a cambiare immediatamente i nameserver autoritativi con quelli di SliceHost appena è stato possibile) e infine per gestire la posta ho creato un account di Google Apps sottoscrivendo il profilo standard nonché gratuito. Livello di soddisfazione: elevato, per ora. Ho diverse idee in testa, tra le varie figura anche la migrazione di questo blog (come del resto mi ripropongo da almeno due anni), ma ogni cosa avverrà a tempo debito.
• Scusate se non ve l’ho mai detto, ma io è un linguaggio di programmazione grandioso. Dinamico, basato sulla prototipizzazione degli oggetti come Javascript, interamente orientato ai messaggi, totalmente privo di keywords, dannatamente curioso e divertente da scoprire. Ok è molto giovane, ci sono pochissime librerie e la documentazione non è propriamente aggiornata con lo stato dello sviluppo, inoltre è probabile che non sarà nemmeno la next big thing in programming (anche se non si sa mai), però vi assicuro che è un linguaggio molto divertente.
• L’altro giorno ho acquistato il gadget allegato all’ultimo numero di Win Magazine (mai comprato in vita mia, sia chiaro): un telecomando IR per PC e Media Center, completo ovviamente di ricevitore USB. Semplice, sottile, 15€… ne volevo uno da tempo, ma non lo desideravo abbastanza intensamente da giustificare una spesa da 30€ o più. Peccato però che non sembri andare molto d’accordo con Zoom Player (da anni il mio player video per Windows preferito) per quanto riguarda la mappatura dei comandi. Fortunatamente però ZP è grande e può essere remotato in maniera piuttosto banale e documentata via TCP/IP oppure usando l’API SendMessage di Windows, per cui ho pensato: perché non sviluppare un’applicazione residente in background che ascolti i comandi provenienti dal mio bel telecomando e li traduca in comandi da inviare a ZP, mappando il tutto come diamine voglio io? Ci sto lavorando in C#, anche se il core è più lavoro di interazione con le API Win32 che altro. Qualche messaggio sull’argomento approderà anche su questi lidi.
• Dalla saga del telecomando è scaturito quasi per caso un altro piccolo progetto, questa volta più generico e potenzialmente più utile anche ad altri. L’idea inziale per l’applicazione di cui vi ho accennato poco sopra prevedeva l’utilizzo integrale di IronRuby per la sua realizzazione, tuttavia mi sono accorto presto che le sue capacità di interop sono ancora particolarmente limitate per diversi aspetti (ecco perché ho scelto di usare C#). In compenso il codice che ho scritto per le prove mi ha portato all’idea di effettuare un porting per IronRuby del modulo Win32API distribuito nella standard lib dell’MRI, il tutto in onore di una sana compatibility-love. Dopo 3 giorni avevo già una prima versione funzionante come testimoniato da questo gist, ora inizia il lavoro di pulizia e ottimizzazioni che si concluderanno con il rilascio del tutto su GitHub e con una serie di post sul blog dedicati all’argomento dal momento che ci sono svariate considerazioni tecniche che potrebbero risultare particolarmente interessanti.

Per ora è tutto. Per ora…

• supporto per una settantina di linguaggi/grammatiche differenti… anche se manca LOLCode, nonostante ci sia Brainfuck
• pastie (qui chiamati gist) pubblici o privati, anonimi oppure "identificati" se effettuati tramite il proprio account GitHub. Le operazioni, in questo caso, sono elencate all’interno della dashboard
• ogni gist può essere composto da file multipli, con possibilità di scaricare comodamente la versione raw di ogni file oppure di effettuare il download del pacchetto intero in formato tar.gz
• possibilità di modificare i propri gist con tanto di accesso allo storico delle varie revisioni
• clone URL pubblici e privati per ogni singolo gist, pronti per essere dati in pasto a Git

Provatelo, è veramente ottimo. Giusto per curiosità, questa è la pagina con i miei Gist pubblici…

Attualmente per installare LuaRocks nella maggior parte delle distribuzioni Linux è necessario prelevare il tarball ed eseguire i soliti passaggi ./configure && make && make install, tuttavia l’installazione sulle Ubuntu-derivate a partire da 8.04 Intrepid Ibex o su Debian a partire da 5.0 Lenny sarà molto più semplice dal momento che basterà installare il pacchetto luarocks tramite apt-get. Per Windows esiste un installer che automatizza le procedure, lasciando all’utente la scelta se installare un interprete Lua basilare senza librerie fornito dallo stesso installer o se utilizzare un interprete già installato nel proprio sistema. Tutte le informazioni necessarie al download e all’installazione di LuaRocks sono disponibili sul relativo sito.

Nel frattempo pochi mesi fa è nato un installer di Lua per Windows chiamato, con molta fantasia, Lua for Windows. Esso include molte delle più note librerie per Lua e un ambiente di sviluppo/debug già configurato e basato su SciTE. Si tratta quindi di un’ottima soluzione per avere in pochi secondi tutto il necessario per poter programmare in Lua, tuttavia LuaRocks non è stato ancora incluso per cui ecco i passaggi da seguire per integrare il tutto:

• Scaricare Lua for Windows (LfW) e procedere con l’installazione: la mia installazione è stata effettuata nel path proposto di default, ovvero C:\Programmi\Lua\5.1
• Scaricare LuaRocks per Windows, decomprimere l’archivio e aprire la shell dei comandi nella directory contenente install.bat
• L’installer di LuaRocks permette di specificare alcune opzioni. Ecco come installarlo in modo che sfrutti l’interprete reso disponibile da LfW e che utilizzi un unico path per l’installazione dei pacchetti rock:

  install /LUA C:\Programmi\Lua\5.1 /BIN C:\Programmi\Lua\5.1 /P C:\Programmi\Lua\5.1\LuaRocks\0.6 /CONFIG C:\Programmi\Lua\5.1\LuaRocks /TREE C:\Programmi\Lua\5.1\LuaRocks\ /SCRIPTS C:\Programmi\Lua\5.1\LuaRocks\ /FORCECONFIG

  Di default LuaRocks permette anche ad utenti non amministrativi di installare dei pacchetti rock locali (solitamente in %APPDATA%/luarocks/rocks/), mentre con l’opzione /FORCECONFIG verrà considerato un unico file di configurazione, quello specificato da /CONFIG, e un unico path per l’installazione di rock e script a livello di sistema, specificati rispettivamente da /TREE e /SCRIPT. Potete fare riferimento alla documentazione per un approfondimento in merito.

• La directory C:\Programmi\Lua\5.1 viene automaticamente aggiunta al PATH di sistema dall’installer di LfW per cui possiamo creare un hardlink ai file luarocks.bat e luarocks-admin.bat con il fine di poter invocare gli stessi più comodamente dalla shell. Da Windows XP in avanti si può operare come segue:

  cd C:\Programmi\Lua\5.1\LuaRocks\0.6
fsutil hardlink create ../../luarocks.bat luarocks.bat
fsutil hardlink create ../../luarocks-admin.bat luarocks-admin.bat

• Modificare la variabile di sistema LUA_PATH aggiungendo ai path già impostati da LfW il seguente percorso per il caricamento dei file della libreria LuaRocks:

  C:\Programmi\Lua\5.1\LuaRocks\0.6\lua\?.lua

Ora LuaRocks è installato e funzionante, basta aprire la shell dei comandi e lanciare luarocks search –all per visualizzare tutti i pacchetti rock disponibili sul server (è disponibile anche un elenco consultabile più comodamente) e luarocks install nomepacchetto per installare i pacchetti rock nel sistema. A questo punto negli script Lua basterà aggiungere la riga require "luarocks.require" che si occuperà di effettuare l’override della funzione require standard di Lua, rendendo possibile il caricamento delle librerie installate tramite LuaRocks. Alternativamente si può ottenere lo stesso risultato lanciando così l’interprete: lua -lluarocks.require

Ecco un esempio di come sfruttare una libreria installata tramite LuaRocks:

-- luarocks install colors

require "luarocks.require"
require "colors"

green = colors.new("#0f8923")

print("Verdolino:", green)    -- Verdolino:    #0f8923

LuaRocks con l’ultima release ha raggiunto un livello di maturità accettabile e l’elenco delle librerie disponibili sotto forma di pacchetti rock è in lento ma costante aumento, ma ci sono alcune applicazioni o framework che ne traggono beneficio per l’installazione e la gestione delle loro dipendenze come per esempio Kepler (un framework per lo sviluppo web generico in Lua), Orbit (un altro framework per lo sviluppo web in Lua, ma MVC oriented) e Sputnik (un wiki scritto in Lua, leggero ma estendibile). Per la cronaca, ecco invece cosa si era costretti a fare solamente un anno fa per avere un’installazione minimale di Lua in Windows e cominciare ad aggiungere librerie come LuaSocket.

Prima di tutto è stata presa una decisione per quanto riguarda la sintassi dichiarativa, infatti precedentemente erano state formulate due possibilità. La prima prevedeva la cattura delle variabili esterne alla chiusura tramite una nuova keyword creata ad hoc, lexical:

$lambda = function($arg1, $arg2) {
    lexical $reference, &$valueByRef;
    // ...
};

La seconda, quella che è stata effettivamente scelta, prevede invece il riutilizzo della keyword già esistente use:

$lambda = function($arg1, $arg2) use ($reference, &$valueByRef) {
    // ...
};

Qualcuno preferiva la prima opzione e personalmente ero dello stesso avviso, ma alla fine la scelta è stata dettata dall’intenzione di raggiungere un compromesso in maniera tale da ottenere le stesse funzionalità mantenendo la consistenza con l’attuale semantica di PHP e senza intaccare la retrocompatibilità.

La prima estensione nella RFC riguarda invece l’utilizzo della keyword static per stabilire se importare o meno $this all’interno di una chiusura definita all’interno del metodo di una classe. Non effettuare l’importazione di $this all’interno di una chiusura quando non necessario permette di ottenere un risparmio non solo in termini di velocità d’esecuzione, anche si tratta di differenze veramente minimali, ma anche e soprattutto di memoria, evitando che delle long-lived closure possano tenere in vita inutilmente le istanze delle classi in cui esse sono state create. La chiusura che cattura $this infatti impedisce che il refcount interno per l’oggetto che referenzia possa arrivare a 0 e ciò ne comporta l’esclusione dal processo automatico di raccolta delle risorse che viene effettuato dal garbage collector. Vediamo un esempio pratico con tanto di risultato:

class NRK {
    private $_whoAmI = __CLASS__;

    public function foo() {
        $method = __METHOD__;
        return function() use ($method) {
            return sprintf("created in %s (w/ \$this):\n%s",
                $method,
                print_r($this, true) ?: 'null'
            );
        };
    }

    public function bar() {
        $method = __METHOD__;
        return static function() use ($method) {
            return sprintf("created in %s (w/o \$this):\n%s",
                $method,
                print_r($this, true) ?: 'null'
            );
        };
    }
}

$nrk = new NRK();
$fun1 = $nrk->foo();
$fun2 = $nrk->bar();

echo $fun1(), "\n", $fun2();

/*
created in NRK::foo (w/ $this):
NRK Object
(
    [_whoAmI:NRK:private] => NRK
)

created in NRK::bar (w/o $this):
null
*/

In realtà trovo che sarebbe molto più comodo e pulito avere $this importata in automatico nel caso essa venga esplicitamente richiamata nel corpo della closure, per il compilatore non sarebbe difficile accorgersene ed agire di conseguenza, ad ogni modo non mi piace l’uso della keyword static dal momento che rende ancora più verbosa la definizione di una chiusura.

Proseguendo con le nuove funzionalità, nell’ottica di una maggiore integrazione con PHP sono state estese le classi ReflectionMethod e ReflectionFunction implementando il metodo getClosure() che permette di ottenere una funzione lambda generata dinamicamente partendo da una funzione o da un metodo di istanza/classe:

class NRK {
    public function instanceMeth()       { return __METHOD__; }
    public static function staticMeth()  { return __METHOD__; }
    public static function methWithArgs($a, $b) { return $a + $b; }
}

$instance = new NRK();

$class = new ReflectionClass('NRK');
$fun1  = $class->getMethod('instanceMeth')->getClosure($instance);
$fun2  = $class->getMethod('staticMeth')->getClosure();
$fun3  = $class->getMethod('methWithArgs')->getClosure();

echo $fun1(), "\n", $fun2(), "\n", $fun3(5, 3);

/*
NRK::instanceMeth
NRK::staticMeth
8
*/

Per finire, un’altra novità ispirata dall’implementazione dell’oggetto Closure riguarda la generalizzazione del concetto di oggetto invocabile attraverso l’implementazione di un nuovo metodo magico, __invoke(). Un esempio vale più di mille parole:

class CallableObject {
    public function __invoke () {
        return 'Guess what?';
    }
}

$callable = new CallableObject();
$notCallable = new stdClass();

echo '$callable is ', is_callable($callable) ? '' : 'not ', "a callable object\n";
echo '$notCallable is ', is_callable($notCallable) ? '' : 'not ', "a callable object\n";

echo $callable();
echo $notCallable();

/*
$callable is a callable object
$notCallable is not a callable object
Guess what?
Fatal error: Function name must be a string in [...]
*/

Tirando le somme lo stato dell’implementazione di lambda e closure in PHP sembrerebbe essere in uno stato particolarmente avanzato al punto tale che lo stesso Andi Gutmans su php.internals ha chiesto, soprattutto ai release manager, di pensare se sia effettivamente possibile includere tutto questo già in PHP 5.3. In effetti PHP 5.3 sarà già ricco di novità di per sè (namespace e collaterali, LSB, __callStatic, etc) quindi l’introduzione di un’altra nuova feature è da valutare bene, tuttavia vista la buona salute della proposta e dei lavori per implementarla sarebbe un peccato dover aspettare un altro anno o più. Intanto però c’è anche chi si chiede: ma alla fine le novità di PHP 6 saranno rappresentate solo dal supporto per Unicode?

$fun = function($name = 'guy') { echo "Hi $name!"; };

printf("Tipo: %s\n", get_class($fun));           // Type: Closure
printf("Callable: %s\n", is_callable($fun));     // Callable: 1

Come possiamo notare, è stato implementato un nuovo tipo in ZE denominato Closure. Closure risulta essere invocabile, alla stessa stregua di funzioni e metodi:

echo $fun();        // Hi guy!
echo $fun('NRK');   // Hi NRK!

Il primo pensiero va a questo punto a tutte quelle funzioni in PHP che accettano delle callback ma in cui comodità ed espressività vengono pesantemente minate dall’attuale modus operandi del linguaggio che prevede due opzioni:

• definire una funzione tradizionale da usare come argomento callback ma sotto forma di stringa (il nome della funzione stessa), dando quindi origine a potenziali bugs galore.
• creare una funzione a runtime usando create_function, opzione che oltre a risultare poco elegante alla vista rischia di introdurre un’altra buona dose di problemi in termini di manutenibilità del codice.

Ecco quindi un confronto tra come è possibile scrivere codice oggi e la possibilità di sviluppare la stessa soluzione attraverso l’utilizzo delle funzioni lambda:

$array = array(1, 2, 3, 4, 5, 6, 7, 8, 9, 10);

/* senza funzioni lambda */
function reducer($a, $b) { return $a * $b; }
$res = array_reduce($array, 'reducer', 1);   // 3628800

/* senza funzioni lambda */
$res = array_reduce($array, create_function('$a, $b', 'return $a * $b;'), 1);   // 3628800

/* con funzion lambda - versione "lunga" */
$reducer = function($a, $b) { return $a * $b; };
$res = array_reduce($array, $reducer, 1);   // 3628800

/* con funzion lambda - versione "breve" */
$res = array_reduce($array, function($a, $b) { return $a * $b; }, 1);   // 3628800

Il fatto che l’oggetto Closure sia a tutti gli effetti visibile in userland permette anche di sfruttare l’hinting dei tipi nel caso volessimo limitare a questo tipo di oggetto alcuni parametri delle nostre funzioni:

function iterate($array, Closure $fun) {
    foreach ($array as $element)
        $fun($element);
}

iterate($array, 'function');   // genera un Catchable Fatal Error, Argument 2 passed to
                               // iterate() must be an instance of Closure, string given

Essendo Closure una vera e propria classe (che, per la cronaca, attualmente espone solo un metodo __toString() seppur vuoto) potrebbe implementare in un ipotetico futuro diverse funzionalità interessanti e chissà, potrebbe anche essere serializzabile. Ad ogni modo, dopo le funzioni lambda passiamo a vedere le closure:

$array = array(1, 2, 3, 4, 5, 6, 7, 8, 9, 10);

$sum = 0;

$fun = function($element) {
    lexical &$sum;
    // ...
    $sum += $element;
};

array_walk($array, $fun);
echo $sum;   // 55

Possiamo notare l’introduzione della keyword lexical (c’è anche la variante use a seconda della patch che si decide di utilizzare) che ci permette di catturare i riferimenti alle variabili esterne al corpo della chiusura. L’introduzione di lexical è dovuta al fatto che con questa implementazione non viene catturato tutto l’ambiente lessicale in cui viene creata la chiusura, come accade invece in altri linguaggi, per motivi legati principalmente alle regole di scope di PHP. Usando lexical possiamo pertanto decidere quali variabili catturare, ma è da notare che attualmente per i tipi numerici o stringa, che per default in PHP sono passati per valore, è necessario creare manualmente un riferimento anteponendo l’ampersand alla variabile catturata, come da esempio. Tecnicamente la cattura per riferimento dovrebbe essere di default anche per questi tipi e lo stesso creatore della patch è del medesimo avviso, tanto più che il terribile global si comporta nello stesso modo creando sempre riferimenti.

In linea di massima l’introduzione di funzioni lambda e closure in PHP sarebbe interessante e in certe situazioni renderebbe la scrittura dei programmi un po’ meno arrabattata con la possibilità di ottenere codice molto più facilmente generalizzabile e più verificabile/manutenibile. Provare è abbastanza facile: basta avere un ambiente configurato per compilare PHP, scaricare i sorgenti di PHP 5.3 o 6.0 dal repository CVS (sì, usano ancora CVS…), applicare una delle patch disponibili, compilare e installare.