Claudiu Persoiu

Blog-ul lui Claudiu Persoiu


Archive for the ‘anonymous functions’ tag

Closures, de la Scheme la Javascript la PHP

without comments

Notiunea de closure in PHP, desi a aparut in PHP 5.3, a fost realizata intr-un mod adecvat abia in 5.4, asa cum am mai spus-o si pe blogul meu.

Wikipedia ne spune:

In computer science, a closure (also lexical closure or function closure) is a function or reference to a function together with a referencing environment—a table storing a reference to each of the non-local variables (also called free variables) of that function.

In PHP nu este un concept foarte popular sau foarte cunoscut. De multe ori acesta este confundat cu Anonymous Functions. In limbajele functionale totusi, acest concept este foarte popular, pentru ca acolo este cu adevarat nevoie de el!

Scheme

Cand Brendan Eich a conceput JavaScript, s-a bazat pe limbajul Scheme si a ajuns sa faca o implementare a acestuia cu o sintaxa de C. Sintaxa C era si este in continuare mult mai populara, iar atunci (1995) limbajul Java era foarte “la moda”.

Sintaxa Scheme este similara cu sintaxa Lisp, in sensul ca se folosesc paranteze in jurul expresiilor pentru a le rula. Operatorii sunt definiti ca si functii si la fel ca o si in cazul functiilor, se pun in partea stanga a parantezei.

Sa luam un exemplu de closure in Scheme:

(define (make-counter)
  (let ((count (begin 
                 (display "run parent function and return 0") 
                 0)))
    (lambda ()
      (set! count (+ count 1))
      (begin 
        (display "inside child function ") 
        count))))

Functia principala seteaza o variabila “count”, cu valoarea 0 si afisaza “run parent function and return 0”, apoi intoarce o alta functie lambda, care incrementeaza variabila definita in functia principala si apoi afisaza “inside child function”.

Functia rezultata din executia functiei principale o stochez intr-o variabila pentru a o putea rula ulterior de mai multe ori:

> (define counter (make-counter))
run parent function and return 0
> (counter)
inside child function 1
> (counter)
inside child function 2

Cu alte cuvinte, de fiecare data cand apelez (make-couter), acesta va intoarce o functie noua care are acces la mediul in care a fost creata. Daca pare ciudat din pricina sintaxei, promit ca in JavaScript va parea mult mai natural.

Acest concept este foarte interesant pentru incapsulare. Mediul la tipul cand functia parinte este executata se poate incapsula, iar ulterior se va folosi de accest mediu fara grija ca acesta se poate schimba din cauze exterioare.

Pentru limbajele functionale acesta este un concept foarte interesant. Cand vine vorba de limbaje obiectuale totusi, conceptul aproape inutil, pentru ca obiectele au si ele rolul de incapsulare.

JavaScript

JavaScript a fost de la inceput un hibrid, un limbaj functional, orientat obiect, cu mostenire bazata pe prototype. Iar daca acestea nu erau suficiente, sintaxa a fost preluata din Java (C).

JavaScript nu a mostenit multe de la Scheme, dar a mostenit conceptul de closure.

Un motiv pentru care era nevoie de closure in Scheme este acela ca daca o functie nu gaseste o variabila in mediul in care se afla, o va cauta in mediul superior. Sa luam un exemplu:

(define x 1)
(define (add-in-env y) (+ x y))

Daca apelam add-in-env cu 2:

(add-in-env 2) -> 3

Pare la fel de ambiguu ca si in JavaScript, dar nu este tocmai asa. In Scheme sa faci mutatie nu e la fel de usor, simplu si transparent, deci o operatie ulterioara de:

(define x 2)

va rezulta intr-o eroare.

In JavaScript a rezultat un hibrid. Mutatia este permisa, dar notiunea de a cauta o variabila in mediul in care te afli a ramas:

var x = 1;
var add_in_env = function (y) {
   return x + y;
}

add_in_env(2); // rezulta 3

Pana aici e ok, dar pentru:

x = 2;
add_in_env(2); // rezulta 4

In acest caz, lucrurile scapa foarte usor de sub control.

Dar, ca sa rezolvam problema, putem pur si simplu sa definim variabila in mediul care isi va termina executia (se va inchide = will close):

var make_counter = function () {
   console.log("run parent function and set counter to 0")
   var count = 0;

   return function () {
       count = count + 1;
       console.log("inside child function");
       return count;
   }
}

var counter = make_counter();
console.log(counter());
console.log(counter());

var counter2 = make_counter();
console.log(counter2());
console.log(counter());
console.log(counter2());

Outputul va fi:

run parent function and set counter to 0
inside child function
1
inside child function
2
run parent function and set counter to 0
inside child function
1
inside child function
3
inside child function
2

Chiar daca functia principala si-a terminat executia, mediul din interiorul ei este pastrat ca un closure pentru functia care a fost intoarsa. Doar in momentul in care si subfunctia nu mai are referinte catre ea memoria alocata pentru closure va fi dezalocata.

Chiar daca JavaScript are obiecte, acestea nu au metode private. O abordare este sa pui un “_” (underscore) in fata numelui functiei si sa o consideri privata. Din punctul meu de vedere asta este ca si cum ii rogi pe cei care vin dupa tine sa o considere o functie privata. Evident acest lucru nu este tocmai consistent.

Sa luam un exemplu:

var obj = {
   _secretFunction : function (key) { console.log(‘do secret ’ + key) },
   doStuff : function (key) { this._secretFunction(key) }
}

obj.doStuff(‘stuff’); // do secret stuff

Aparent avem o metoda publica “doStuff” si una privata “_secretFunction”. Totusi nu poti preveni un utilizator sa apeleze “_secretFunction”, sau mai rau, sa o modifice:

obj._secretFunction = function (key) { console.log('new secret ' + key); }

obj.doStuff('stuff'); // new secret stuff

Daca vrem ca functia sa fie ascunsa, iar acest lucru sa fie evident pentru toata lumea, din nou putem folosi un closure:

var obj = (function () {
   var secretFunction =  function (key) { console.log(‘do secret ’ + key) }

   return {
      doStuff : function (key) { 
         secretFunction(key) 
      }
   }
})();

obj.doStuff(‘stuff’); // do secret stuff

Pentru ca functia parinte se va executa la inceput, practic spatiul in care a fost definit secretFunction si-a terminat deja executia, incapsuland logica. Obiectul intors poate sa apeleze functia pentru ca este definit in acelasi mediu ca si obiectul.

Pare complicat prima data, dar de fapt este foarte simplu cand intelegi conceptul.

Si apoi a fost… PHP

PHP inglobeaza multe optiuni diferite. PHP s-a dezvoltat initial ca un framework Perl, ulterior engine-ul fiind scris in C.

PHP este un limbaj dinamic care inglobeaza foarte multe concepte, de la obiecte, interfete si functii anonime, pana la goto labels. Nu este foarte clara directia in care ar trebui sa se dezolte limbajul, mai degraba ofera posibilitatea pentru abordari diferite.

In istoria ciudata a PHP, undeva in versiunea 4 a fost introdusa o sintaxa pentru Anonymous Functions, dar abia in PHP 5.3 a aparut o versiune mai “normala“.

Tot in versiunea 5.3 a fost introdusa si prima varianta de closures:

$scalar = 5;

$closure = function () use ($scalar) {
     return 'Scalar: ' . $scalar . PHP_EOL;
};

echo $closure(); // Scalar: 5

$scalar = 7;

echo $closure(); // Scalar: 5

Versiunea functioneaza in mare parte, dar trebuie sa specifici ce vei trimite catre closure.

Si mai exista cateva inconveniente:

<?php 
class Foo {         
   private function privateMethod() {                 
      return 'Inside private method';         
   }

   public function bar() {                 
      $obj = $this;                 
      return function () use ($obj) {                         
         return $obj->privateMethod();
      };
   }
}

$obj = new Foo();
$closure = $obj->bar();
echo $closure();

Fatal error:  Call to private method Foo::privateMethod() from context '' in [...][...] on line 10

Nu functioneaza pentru ca nu poti trimite $this ca parametru la closure, iar daca faci artificiul de mai sus tot nu vei putea accesa metodele private. Nu uitati, asta se intampla in PHP 5.3.

Ideea de a introduce acest tip de closure mi se pare bizara. Nu este prima daca cand in PHP se introduce un feature “bizar”, dupa cum vorbeam mai sus si de Anonymous Function. Pare work in progress.

Cred ca toata lumea se astepta ca acest feature sa functioneze la fel ca in JavaScript. Cred ca doar datorita JavaScript conceptul de closure a devenit atat de popular.

In versiunea PHP 5.4 lucrurile s-au mai schimbat, avem in sfarsit closures asa cum ne asteptam:

class Foo {
   private function privateMethod() {
      return 'Inside private method';
   }

   public function bar() {
      return function () {
         return $this->privateMethod();
      };
   }
}

$obj = new Foo();
$closure = $obj->bar();
echo $closure(); // Inside private method

Functioneaza!

Poti chiar sa spui:

unset($obj);
echo $closure();

si va functiona, pentru ca obiectul in interiorul caruia a fost definit closure-ul a ramas in memorie pana cand se va termina executia scriptului, sau se va apela:

unset($closure);

Pentru mai multe detalii despre cum functioneaza closure in PHP 5.4, puteti citi acest blog.

Written by Claudiu Persoiu

10 April 2013 at 10:02 AM

PHP 5.4 – Closures asa cum ar trebui!

with 5 comments

Notiunea de Closure, a fost introdusa in PHP 5.3, o data cu o noua sintaxa, “mai traditionala” pentru functiile anonime.

PHP 5.3

In 5.3, un closure se baza pe termenul “use”, care transmite anumite variabile functiei anonime, transformand-o intr-un closure.

Problema este ca functia anonima nu va avea acces decat la variabilele trimise folosind “use”. In cazul obiectelor ele sunt trimise prin referinta, dar in cazul variabilelor scalare (int, string, etc.) acestea se transmit prin valoare, asa cum face implicit in PHP 5+:

$scalar = 5;

$closure = function () use ($scalar) {
     return 'Scalar: ' . $scalar . PHP_EOL;
};

echo $closure(); // Scalar: 5

$scalar = 7;

echo $closure(); // Scalar: 5

O alta problema este ca nu se pot trimite $this in cadrul obiectelor, deci doar proprietatile sau metodele care sunt publice nu pot fi accesate de closure.

PHP 5.4

In PHP 5.4 folosirea cuvantului “use” este optionala, iar tot mediul in care functia anonima a fost creata este disponibil in interiorul functiei.

Avantajul este ca atunci cand functia anonima este generata in interiorul unei alte functii, sau a unei metode, functia anonima va putea accesa mediul in care aceasta a fost creata chiar si dupa terminarea executiei acestuia. Obiectele din mediul creat se vor dezaloca de abea dupa ce se ultima referinta catre closure se va sterge:

class testClass {

        private $changeableVar = 1;
        private $bigVar;

        public function __construct() {
                // Allocate a big variable so we can see the changes in memory
                $this->bigVar = str_repeat("BigWord", 5000);
        }

        /**
         * O metoda care intoarce un closure
         */
        public function closure() {

                return function () {
                        // Display the value of a private property of the object
                        echo 'Private property: ' . $this->changeableVar.PHP_EOL;

                        // Change the value of a private property of the object
                        $this->changeableVar = 2;
                };
        }

        /**
         * O metoda care afisaza o variabila privata
         */
        public function showChangeableVar() {
                echo 'Private property in method: ' . $this->changeableVar.PHP_EOL;
        }

}

// Memoria inainte sa fie alocat obiectul
echo "Memory: " . memory_get_usage() . PHP_EOL; // Memory: 229896

// Creare obiect
$testObj = new testClass();

// Creare closure
$closure = $testObj->closure();

// Executie closure
$closure(); // Private property: 1

// Afisare valoare curenta a proprietatii private
$testObj->showChangeableVar(); // Private property in method: 2

// Memoria inainte sa fie desalocat obiectul
echo "Memory: ". memory_get_usage() . PHP_EOL; // Memory: 266240

// Dezalocare obiect
unset($testObj);

// Memoria dupa ce a fost dezalocat obiectul, nu este o diferenta mare in memorie
echo "Memory: ". memory_get_usage() . PHP_EOL; // Memory: 266152

// Executie closure dupa ce obiectul in care a fost creata a fost dezalocat
echo $closure(); // Private property: 2

// Dezalocat closure si o data cu el mediul in care a fost generat
unset($closure);

// Memoria dupa ce a fost stearsa ultima referinta catre obiect
echo "Memory: " . memory_get_usage() . PHP_EOL; // Memory: 230416

Callable type hinting

Inca un nou lucru introdus legat de closures introdus in PHP 5.4 este un nou “type hint”: “callable”. De fapt “callable” se refera la orice functie anonima, chiar si la un nou mod de a apela o metoda a unui obiect:

<?php
// O functie care foloseste type hinting
function typeHinting(callable $a) {
     echo $a() . PHP_EOL;
}

// Un closure
$closure = function () {
     return __FUNCTION__;
};

// Apelare functie cu type hinting cu un closure ca argument
typeHinting($closure); // {closure}

class testClass {
     public function testMethod() {
          return __METHOD__;
     }
}

// Un obiect de test
$testObj = new testClass();

// Noua forma de apelare a unei metode dintr-un obiect
$objCallable = array($testObj, 'testMethod');

// Apelare functie type hinting cu noua forma de apelare ca argument
typeHinting($objCallable); // testClass::testMethod

Cred ca de abea acum este momentul sa spunem ca PHP suporta closures cu adevarat!

Written by Claudiu Persoiu

11 February 2012 at 5:10 PM

Posted in PHP

Tagged with , , , ,

Closures si functii lambda in PHP vs. JavaScript

with 2 comments

JavaScript si PHP suporta atat functii lambda cat si closures. Dar termenii sunt putin intelesi in ambele libaje de programare si de multe ori sunt confundati.

Functii Lambda

Mai sunt numite si functii anonime. Acestea se refera la functii care pot fi apelate fara sa fie neaparat legate de un identificator. Unul din scopurile lor este de a fi pasate ca argumente. Numele de Lambda li se trage de la Alonzo Church, inventatorul lambda calculus in 1936. In lambda calculus toate functiile sunt anonime.

JavaScript

In JavaScript functiile lambda fac parte din setul de baza si reprezinta metoda preferata de creare a unei functii.

De exemplu:

var add = function (a, b) {
     return a + b;
}
alert(add(1, 2)); // 3

Functiile lambda sunt folosite aproape in orice context cand vine vorba de JavaScript, un exemplu este:

window.onload = function (e) {
     alert('Pagina s-a incarcat!');
}

PHP

In PHP, functiile lambda au fost introduse de la versiune 4.0.1 folosind create_function. In versiunea 5.3+ a fost adaugata si sintaxa similara cu JavaScript, un mod mult mai lizibil si elegant de a definii o functie.

Asta inseamna ca in PHP exista doua moduri de a genera o functie lambda:

// PHP 4.0.1+
$add = create_function('$a, $b', 'return $a + $b;');

// vs.

// PHP 5.3+
$add = function ($a, $b) {
     return $a + $b;
};

echo $add(1,2); // 3

Functiile lambda pot fi folosite ca parametru pentru alte functii, cum ar fi usort:

$array = array(4, 3, 5, 1, 2);
usort($array, function ($a, $b) {
     if ($a == $b) {
          return 0;
     }
     return ($a < $b) ? -1 : 1;
});

Chiar mai mult, PHP 5.3+ permite apelarea unui obiect ca o functie anonima:

class test {
     function __invoke($a) {
          echo $a;
     }
}
$a = new test();
$a('test'); // 'test'

Closures

Notiunea de closure este notiunea cu adevarat neinteleasa dintre cele doua. In general confuzia apare pentru ca implementarea de cloasure poate presupune si functii lambda. Un closure se refera la capacitatea unei functii/obiect de a accesa mediul in care aceasta a fost creat(a) chiar daca executia functiei parinte s-a terminat. Cu alte cuvinte functia/obiectul intors de un cloasure pastreaza mediul in care a fost definita.

In JavaScript notiunea de closure face parte din arsenalul de baza, pentru ca limbajul nu are la baza un model obiectual traditional ci unul bazat pe prototype si functii. Dar JavaScript mai are si cateva reminescente, cum ar fi faptul ca poti folosi “new” pentru a construi un obiect pe baza unei functii care joaca roul de clasa. In PHP este mai degraba o noua posibilitate de abordare a problemelor, PHP facand parte din familia de limbaje cu model obiectual traditional.

JavaScript
In JavaScript notiunea de closure este foarte folosita, iar popularitatea se datoreaza faptului ca JavaScript nu este un limbaj obiectual traditional, ci unul functional, bazat pe mostenire prototype.

In JavaScript nu exista notiunea de Public, Private si Protected, exista doar Public si Private iar obiectele pot mostenii unele de la altele, fara sa foloseasca clase.

O alta problema este mediul (scope), care in mod implicit este cel global. Prin closure aceste probleme pot fi rezolvate intr-un mod elegant:

var closure = function () {
     var sum = 0;
     return {
          add: function (nr) {
               sum += nr;
          },
          getSum: function () {
               return sum;
          }
     }
}();

closure.add(1);
closure.add(2);
console.log(closure.getSum());

In exemplul de mai sus, sum este o proprietate privata iar aceasta teoretic, putea fi accesata si modificata doar din functia closure. Partea interesanta este ca parantezele de la finalul definitiei de functiei semnifica faptul ca aceasta functie se va si executa si deci va intoarce rezultatul care este un obiect. In acest moment functia initiala nu mai exista decat pentru a servi obiectul intors, incapsuland astfel variabila privata.

Desi functia si-a terminat executia, prin intermediu acestul closure obiectul returnat poate accesa variabilele definite in interiorul functiei, pentru ca este mediul in care a fost creeat.

Problema devine mai interesanta atunci cand o functie intoarce o alta functie:

var counter = function () {
    var counter = 0;
    console.log('in closure');
    return function () {
        console.log('in functia anonima');
        return ++counter;
    };
};
var counter1 = counter();

console.log(counter1()); // 1

var counter2 = counter();
console.log(counter2()); // 1
console.log(counter1()); // 2

Output-ul va fi:

in closure
in functia anonima
1
in closure
in functia anonima
1
in functia anonima
2

Ce se intampla de fapt este ca prima functie se executa si intoarce o functie anonima care inca mai poate accesa mediul in care a fost creata. Dupa parerea mea de aici vine confuzia dintre closures si lambda functions, pentru ca o functie intoarce o alta functie.

Diferenta dintre exemple este ca in primul exemplu functia initiala de closure se executa imediat, iar in al doilea exemplu se poate vedea ca atunci cand counter se executa intoarce un rezultat, care este de fapt o definitie de functie, care la randul lui poate fi executata. Evident si acest exemplu poate fi adaptat sa se comporte precum cel precedent folosind paranteze la final.

PHP

Cum spuneam si mai sus, in PHP notiunea de closure nu este la fel de importanta ca in JavaScript.

Daca functiile lambda sunt disponibile in limbaj incepand cu versiunea 4, closure au aparut de abea dupa PHP 5.3+

Datorita mediului (scope) de executie care este de tip block in PHP se realizeaza o incapsulare mai buna dar si mai putin flexibila fata de JavaScript. Practic in PHP trebuie specificat cu ajutorul instructiunii use ce anume va putea accesa functia anonima din closure-ul care si-a terminat executia.

function closure () {
     $c = 0;
     return function ($a) use (&$c) {
          $c += $a;
          echo $a . ', ' . $c . PHP_EOL;
     };
}

$closure = closure();

$closure(1);
$closure(2);

Spre deosebire de JavaScript in PHP nu se pot realiza closure care sa intoarca un obiect, sau mai bine zis obiectul nu poate fi legat de mediul in care a fost creat, decat sa zicem, daca nu se trimit parametrii la constructor prin referinta, metoda nu foarte eleganta care nu vad in ce scenariu ar avea neaparata nevoie de closure.

Ca o paralela la exemplele  de la JavaScript, in loc de parantezele “()” de la finalul functiei, in PHP pentru a executa functia imediat dupa definire se pot folosii call_user_func() sau call_user_func_array():

$closure = call_user_func(function () {
    $c = 0;
    return function ($a) use (&$c) {
        $c += $a;
        echo $a . ', ' . $c . PHP_EOL;

    };
});

$closure(1);
$closure(2);

Written by Claudiu Persoiu

16 April 2011 at 6:02 PM