Funkce callback()

Podle mě je to celkem přebytečná blbost, když někod bude chtit vytvořit callback tak jej vytvoří pomocí pole a je to , nevim proč zmatkovat

Výhodu bych viděl v trochu intuitivnějším zápise, ze kterého je hned jasné, že jde o přiřazení callbacku k nějaké události místo předání pole s $this a „nějakým“ stringem..

enoice napsal(a):

cb($this, "method");

? :-)

To je dost „nesamopopisné“, nic neříkající fce cb(). Když už, tak callback(). Ale taky se mi zdá, že je to zbytečné.

Malo by to hádzať CallbackException aby každý vedel, že je to callback :)))

Ta kontrola callbacku už při vytvoření je lákavá…

Plus také to, že PHP 5.2.0 a 5.2.1, myslím, neumí callbacky na statické funkce pomocí Class::method, ale jen array('Class', 'method'). Nemuselo by se toto tedy řešit až na úrovní volání callbacku (pro což myslím vznikla i funkce fixCallback), ale šlo by přímo v této funkci.

Kontrola callbacku pri vytvorení – výborné.

A nebol na niečo takéto kedysi Nette\Callback?

taky si myslím, že by to tam mohlo být, navíc IDE ti krásně napoví i parametry, což se u pole říct nedá…

Jod napsal(a):

Podla mňa, keď bude možné zadávať callback ako pole a aj cez funkciu nejakého Componentu nič sa tým nepokazí.

Jak by vypadalo toto v praxi?

$form = new AppForm;
//...
$form->onSubmit($this, 'fooFormSubmitted');

Myšleno jako zkratka pro callback při použítí přímo u formuláře.

Editoval Majkl578 (15. 10. 2009 12:25)

Pozri do prvého príspevku od Davida, tam to máš.

Jsem pro vytvoření funkce callback, implementace pomocí globální funkce je pragmatická.

• + možnost kontroly správnosti již při vytvoření callbacku se může ukázat jako velmi produktivní
• + přehlednější kód
• + zachování možnosti tvorby callbacku pomocí array($this, 'method')
• – zpomalení, předpokládám ale že neměřitelné

Editoval jasir (19. 10. 2009 15:52)

Když už jsme u fixCallback tak to jen tak snadno nezmizí, globální funkce callback bude vracet vždy pole, jenže v tom případě se to bude prohánět fixCallback i napopodruhé protože nemáme jak jednoduše dát vědět, že už to již jednou bylo upravené, ale stejně to asi nebude znát na výkonu.

S odstupem času jsem dnes funkci callback() implementoval. Nejlepší bude ji ověřit praxí, odstranit se dá vždycky.

Nejprve pár nesouvislých bodů, které jsem měl na mysli během zvažování způsobu implementace:

• který zápis callbacku by v PHP vypadal srozumitelněji? array($a, $b) vs. callback($a, $b)
• PHP 5.3 zavádí closures, které lze volat přes $callback($arg, ...)
• klasické callbacky lze volat pouze přes neobjektové call_user_func($callback, $arg, ...)
• pokud se volání nezdaří, vygeneruje se pouze warning (!)
• striktnost lze zajistit pouze důsledným kontrolováním přes is_callable()
• do verze PHP 5.2.1 nelze použít zápis $callback = 'Trida::metoda', je třeba pole
• před verzí PHP 5.3 nelze volat objekt s magickou metodou __invoke
• kontrola callbacků v okamžiku vytvoření může být výhodná při vývoji, může však načítat třídy, které nebudou při běhu nakonec potřeba

Implementace znamenala comeback pro třídu Nette\Callback ;) Funkce callback je pouze její továrničkou. Což jde mimo coding styles frameworku, je to vlastně jediná veřejná funkce v celém frameworku. (Aby nebyla sama, přidal jsem ji ještě funkci dump() volající Debug::dump).

Zdá se mi, že tato úprava framework trošku pročistila. Takže snad je to krok správným směrem.

Nad tímhle furt váhám, protože fakt nemám rád, když se jedna věc dá udělat dvěma způsoby. A __invoke existovat musí. Ale asi jsem našel argument pro invoke(), protože ani v PHP 5.3 nejde udělat:

$methodInfo = new MethodReflection('B', 'foo');
$methodInfo->getCallback()(...) // nelze
$methodInfo->callback(...) // nelze; callback je property getCallback()
$methodInfo->callback->invoke(...)

tudíš se musí psát __invoke.

David Grudl: A proč by to mělo fungovat?

Neříkám, že by to mělo fungovat, ale že se člověk psaní __invoke() stejně nevyhne a tak má smysl vytvořit alias invoke().

HosipLan napsal(a):

Davide, malá chybka:)

Na kterém řádku konkrétně?

Komentáře jsou kvůli převaděči na PHP 5.3. Zeptám se jinak: narazil jsi na nějakou chybu, nebo máš jen dojem, že je tam chyba? ;)

A nemáš nějakou starší verzi?

Vždy prosím zkus, jestli se to týká aktuální verze. Tenhle „bug“ existoval asi hodinu po prvním zveřejnění třídy Callback, což je už mimo mou rozlišovací schopnost a paměť.

Nemohla by třída Callback dostat ještě jeden atribut, kam by si ukládala předem parametry se kterými by se pak volala? Abych si mohl v jedné části aplikace nadefinovat callback i s parametry a v jiné jej spustit.

Díky za info, o curryingu jsem neslyšel, rád jsem si doplnil vzdělání.

I tak mi ale přijde, že na základní věci by bylo jednodušší využít callbacků. Viz srovnání:

class MyClass
{
	public function doSomething($param)
	{
		// do something
	}

	public function foobar()
	{
		// pomoci curryingu
		$this2 = $this; // http://bugs.php.net/bug.php?id=49543
		$callback = function () use ($this2) { $this2->doSomething('param'); };

		// pomoci callbacku
		$callback = callback($this, 'doSomething')->setArgs('param');
	}
}

Je jasné, že na případy, kdy se přidávají parametry i při vytváření i při volání je mnohem praktičtější currying, ale mě v naprosté většině případů bude stačit jednoduchý callback. Krom toho je to použitelné i pro lidi s PHP 5.2.

když už něco takovýho řešit tak bych přidal třídě Callback metodu use a pak to používal takhle:

<?php
$callback = callback($object, 'method')->use($arg1, $arg2);
?>

Když currying, udělal bych ho tak, jak funguje ve funkcionálních jazycích jako Haskell, OCaml atp. Obal nativního callbacku by při zavolání zkontroloval, jestli dostal alespoň tolik argumentů, kolik nativní callback očekává (to by se asi muselo kontrolovat reflexí). Dostal-li by, zavolal by nativní callback a vrátil jeho návratovou hodnotu. Dostal-li by méně, vrátil by „curryfikovanou“ obálku (callback + některé z jeho argumentů). Nemá cenu podobnými hračkami zpomalovat přímo Callback, protože se to využije asi ne na moc místech. Místo toho by pro curryfikované funkce mohla být třída, řekněme, CurriedCallback.

<?php
function add($a, $b) {
    return $a + $b;
}

$add = curry('add'); // vrátí instanci CurriedCallback
$inc = $add(1); // taktéž vrátí instanci CurriedCallback, s prvním argument inicializovaným na 1

array_map($inc, array(1, 2, 3, 4, 5)); // === array(2, 3, 4, 5, 6)

Jo, ale pokud to nemá měnit stav, ale jen vytvořit obálku, pak je název začínající na „set“ poněkud zavádějící.
Jinak obálku jsem navrhoval přesně z tohoto důvodu. Kontrola argumentů je v obálce poněkud problematická, má-li fungovat na obecný callback. Navíc asi i zbytečná, protože to tu obstarává PHP, ne? Je to sice trošku leaky abstraction, ale IMHO je to to méně špatné řešení.