[pago]

Hi,

ich überlege aktuell, wie man Closures in PHP realisieren könnte. (Kurzdefinition für Closure: Anonyme Funktion, die Zugriff auf den Scope (d.h. Variablen & Funktionen) hat, in dem sie definiert wurde)

Das darf von mir aus 100 Zeilen PHP-Code involvieren und extrem repetitiv sein, Hauptsache ich krieg's irgendwie hin.

Mein bisheriger Ansatz sieht so aus:

PHP-Code:

class Foo {
    private $stack = array();
    
    private function ____closure($n) {
        // get top of stack
        $tos = $this->stack[count($this->stack)-1];
        // extract its variables to get hold of local variables
        extract($tos, EXTR_SKIP);
        // push lexical scope and this scope onto stack (in case we're calling
        // an inner closure
        $this->stack[] = array_merge($tos, array($n));
        // invoke actual code
        $result = $y*$n;
        // pop the stack
        array_pop($this->stack);
        // return the result
        return $result;
    }
    
    public function doSomething($x, $y) {
        // push local variables on stack
        $this->stack[] = array($x,$y);
        // invoke actual code
        $result = array_map(array($this, '____closure'), $x);
        // pop the stack
        array_pop($this->stack);
        // return the result
        return $result;
    }
} 


Das müsste eigentlich funktionieren, selbst wenn in der Closure nochmal eine Closure wäre. Jedenfalls wenn ich bei meinen rein theoretischen Überlegungen keinen Fehler gemacht habe.

Problematisch wird es aber schon, wenn ich eine Closure zurückgeben will oder einer Funktion übergebe, die sie nicht direkt ausführt (dadurch wird der Stack geleert, ohne das die Closure Zugriff darauf hatte).

Hat jemand ne Idee, wie ich das Problem lösen kann? Oder gibt es keine Lösung (auch die Antwort würde mir helfen, weil ich dann nicht weiter überlegen müsste)?

Danke
- Patrick

[MrNiceGuy]

Ähm, also ich habe mal eben versucht mir anhand des Textes bei Wikipedia anzueignen, was es mit dem closure aufsich haben soll, aber ehrlichgesagt habe ich denn Sinn und Zweck nicht wirklich hinterblicken können. Was wäre ein sinnvoller Anwendungsbereich für soetwas?! Und die Klasse da oben verstehe ich auch gerade nicht so richtig. Was sollen die Methoden bringen? Wie sollen sie aufgerufen werden? Und wenn ich das gerade richtig überflogen habe würde der Stack mit jedem Aufruf von ____closure($n) um ein weiteres Element erweitert, wobei vom vorherigen alle Inhalte plus den Übergabeparameter in den Stack geschrieben werden!? Das würde dann aber verdammt viel Speicherverbrauch bedeuten für immer die gleichen Daten?! *kratzamkopf*

Ich versuche nochmal diese kurze aber irgendwie doch wirre Klasse zu verstehen und den Sinn zu hinterblicken, wobei mir das momentan äußerst schwer fällt, nicht zuletzt, weil ich den Sinn hinter der Funktionalität von closures nicht verstanden habe, vielleicht kann mir da jemand auf die Sprünge helfen!? Die Beispiele bei Wikipedia helfen leider nicht wirklich weiter...

[pago]

Hmm ja okay. In meinem Fall möchte ich eine Möglichkeit haben, um eine Callback-Funktion zu erzeugen, die Zugriff auf lokale Variablen und alle Methoden der Klasse, in der sie definiert wurde, hat.

Sinn macht das z.B. in Kooperation mit array_map und array_reduce.
Einfaches Beispiel in PHP:

PHP-Code:

function square($x) { return $x*$x; }
$data = array(1,2,3,4);
print_r(array_map('square', $data)); 


Nur das ich das ganze in "viel komplexer" brauche (bzw. es wäre schön, das komplexer zu haben, weil die primitive Lösung [anonyme Funktionen] nunmal primitiv und vorallem limitiert ist...).

Wenn dir das beim Verständnis hilft, kann ich dir gern eine genauere Erklärung meiner Motivation geben, aber ich weise mal vorsichtig darauf hin, dass das etwas umfangreicher werden könnte.

Davon ab habe ich einen Alternativen Ansatz gefunden, der in vielen Bereichen besser funktioniert, aber streikt, wenn ich private/protected Methoden aufrufen will (kurz: Ich erzeuge eine weitere Klasse, die den state speichert und zur Verfügung stellt, dann bin ich aber nicht mehr in der Original-Klasse, habe also keinen Zugriff auf private Methoden).
Java bietet via Reflection-API die Möglichkeit, auch private Methoden auszuführen. Kann PHP das auch?

[robo47]

Zitat von pago

Java bietet via Reflection-API die Möglichkeit, auch private Methoden auszuführen. Kann PHP das auch?

Suchst du die: http://de3.php.net/oop5.reflection ?
Ob sie das kann weis ich nicht.

[pago]

Hinweis: Der Versuch, eine private, protected oder abstract Methode aufzurufen, wird darin enden, dass eine Exception aus der invoke() Methode geworfen wird.

Jo. Dann muss ich mir was anderes überlegen oder die Begrenzung auf öffentliche Methoden in kauf nehmen, falls niemandem sonst noch was einfällt.

[bobby]

Nur der Vollständigkeit halber: http://schlitt.info/applications/blo...roperties.html

bobby.

[MrNiceGuy]

Zitat von pago

Hmm ja okay. In meinem Fall möchte ich eine Möglichkeit haben, um eine Callback-Funktion zu erzeugen, die Zugriff auf lokale Variablen und alle Methoden der Klasse, in der sie definiert wurde, hat.

OK, also ich verstehe das jetzt so, dass du innerhalb einer Klasse eien Callback-Methode schreiben willst, die Zugriff sowohl auf die globalen Variablen der Klasse, als auch auf die Variablen, die in einzelnen Methoden definiert wurden, hat. OK, allerdings kann ich dann nicht so ganz nachvollziehen, warum das Beispiel so kompliziert gestaltet wurde!? Wäre da folgender Weg nicht etwas einfacher?

PHP-Code:

<?php
class test
{
  protected $integerY = NULL;

  protected function methodCallback ($integerX)
  {
    return $integerX * $this->integerY;
  }
  
  public function methodDoSomething ($arrayX, $integerY)
  {
    $this->integerY = $integerY;
    $arrayResult = array_map (array ($this, 'methodCallback'), $arrayX);
    $this->integerY = NULL;
    return $arrayResult;
  }
}
?>

[pago]

Was passiert bei Rekursion? Was ist, wenn zwei Funktionen einen Parameter mit gleichem Namen haben (wobei das das geringere Problem ist, den Namen kann ich ja generieren, so dass der jeweils anders ist)?

Ich mach's kurz und schmerzlos: Ich habe eine funktionale Template-/Programmiersprache, die ich nach PHP kompiliere. Closures wäre ein extrem nützliches Feature, dass ich gern implementieren würde. Die Implementation muss aber generisch sein (d.h. ich muss sie generieren können, ohne irgendwas anpassen zu müssen) und sollte möglichst effizient sein. Von daher geh ich davon aus, dass ich den Kompromiss mit "nur öffentliche Methoden" wählen werde oder das Feature ganz draußen lasse.

Danke für die Hilfe.